Fix error index disable.

AMagistroni · Sep 19, 2021 · a28bf56 · a28bf56
1 parent c72e511
commit a28bf56
Show file tree

Hide file tree

Showing 13 changed files with 210 additions and 39 deletions.
diff --git a/SqlSchemaCompare.Core/Common/EnumExtension.cs b/SqlSchemaCompare.Core/Common/EnumExtension.cs
diff --git a/SqlSchemaCompare.Core/Common/ErrorWriter.cs b/SqlSchemaCompare.Core/Common/ErrorWriter.cs
@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace SqlSchemaCompare.Core.Common
 {
-    public class ErrorWriter: IErrorWriter
+    public class ErrorWriter : IErrorWriter
     {
         public string GetErrors(IEnumerable<ErrorParser> errorsOrigin, IEnumerable<ErrorParser> errorsDestination)
         {

diff --git a/SqlSchemaCompare.Core/TSql/Factory/FactoryBase.cs b/SqlSchemaCompare.Core/TSql/Factory/FactoryBase.cs
@@ -1,4 +1,5 @@
 using SqlSchemaCompare.Core.DbStructures;
+using System;
 
 namespace SqlSchemaCompare.Core.TSql.Factory
 {
@@ -11,7 +12,7 @@ protected Operation GetOperation(string operation)
                 return Operation.Create;
             else if (operation == "ALTER")
                 return Operation.Alter;
-            else return Operation.Drop;
+            else throw new NotImplementedException();
         }
     }
 }
diff --git a/SqlSchemaCompare.Core/TSql/Factory/TSqlIndexFactory.cs b/SqlSchemaCompare.Core/TSql/Factory/TSqlIndexFactory.cs
@@ -33,7 +33,8 @@ public DbObject CreateAlter(ParserRuleContext context, ICharStream stream)
                 Name = indexContext.id_().GetText(),
                 Schema = string.Empty,
                 Operation = GetOperation(indexContext.GetChild(0).GetText()),
-                ParentName = indexContext.table_name().GetText()
+                ParentName = indexContext.table_name().GetText(),
+                ColumnNames = Enumerable.Empty<string>()
             };
         }
     }

diff --git a/SqlSchemaCompare.Core/TSql/TSqlSchemaBuilder.cs b/SqlSchemaCompare.Core/TSql/TSqlSchemaBuilder.cs
@@ -38,13 +38,7 @@ public string GetStartCommentInLine()
             return "--";
         }
 
-        public string BuildUse(string databaseName)
-        {
-            if (databaseName.Contains("["))
-                return $"USE {databaseName}";
-            else
-                return $"USE [{databaseName}]";
-        }
+        public string BuildUse(string databaseName) => $"USE {databaseName}";
 
         public string BuildSeparator()
         {

diff --git a/SqlSchemaCompare.Core/UpdateSchemaManager.cs b/SqlSchemaCompare.Core/UpdateSchemaManager.cs
@@ -10,7 +10,6 @@ namespace SqlSchemaCompare.Core
     public class UpdateSchemaManager
     {
         private readonly ISchemaBuilder _schemaBuilder;
-        private IEnumerable<DbObjectType> _selectedObjectType;
         public UpdateSchemaManager(ISchemaBuilder schemaBuilder)
         {
             _schemaBuilder = schemaBuilder;
@@ -71,7 +70,6 @@ public UpdateSchemaManager(ISchemaBuilder schemaBuilder)
 
         public string UpdateSchema(IEnumerable<DbObject> sourceObjects, IEnumerable<DbObject> destinationObjects, IEnumerable<DbObjectType> selectedObjectType)
         {
-            _selectedObjectType = selectedObjectType;
             ResultProcessDbObject resultProcessDbObject = new();
 
             ProcessUser(sourceObjects, destinationObjects, resultProcessDbObject);
@@ -97,7 +95,7 @@ public string UpdateSchema(IEnumerable<DbObject> sourceObjects, IEnumerable<DbOb
 
                 foreach (var objectToWrite in OrderItemSchema)
                 {
-                    if (_selectedObjectType.Contains(objectToWrite.DbObjectType))
+                    if (selectedObjectType.Contains(objectToWrite.DbObjectType))
                     {
                         var dbObjects = objectToWrite.Operation switch
                         {
@@ -222,10 +220,15 @@ private void ProcessTable(IEnumerable<DbObject> sourceObjects, IEnumerable<DbObj
                     resultProcessDbObject.AddOperation(constraintsToAlter, Operation.Create);
 
                     var indexToCreate = CreateDbObjectByName(tableOrigin.Indexes, destinationTable.Indexes, resultProcessDbObject);
-                    DropDbObjectByName(tableOrigin.Indexes, destinationTable.Indexes, resultProcessDbObject);
+                    var indexToDrop = DropDbObjectByName(tableOrigin.Indexes, destinationTable.Indexes)
+                                        .GroupBy(x => x.Identifier)
+                                        .Select(x => x.First()).ToList();
+                    var identifierToDrop = indexToDrop.Select(x => x.Identifier);
+                    resultProcessDbObject.AddOperation(indexToDrop, Operation.Drop);
 
                     var indexToAlter = tableOrigin.Indexes
                         .Except(indexToCreate)
+                        .Where(x => !identifierToDrop.Contains(x.Identifier)) // Discard index dropped from index to alter
                         .Where(x => !destinationTable.Indexes.Contains(x)).ToList(); //discard object present in origin, present in destination and equals
 
                     resultProcessDbObject.AddOperation(indexToAlter, Operation.Drop);
@@ -242,9 +245,9 @@ private void ProcessTable(IEnumerable<DbObject> sourceObjects, IEnumerable<DbObj
         }
         private void ProcessTableColumn(Table table, Table destinationTable, ResultProcessDbObject resultProcessDbObject)
         {
-            IList<Table.Column> columnsToAdd;
-            IList<Table.Column> columnsToDrop;
-            IList<Table.Column> columnsToAlter;
+            IList<Column> columnsToAdd;
+            IList<Column> columnsToDrop;
+            IList<Column> columnsToAlter;
 
             columnsToAdd = table.Columns
                             .Where(x =>
@@ -364,7 +367,14 @@ private List<T> DropDbObject<T>(IEnumerable<T> sourceObjects, IEnumerable<T> des
                     .Contains(dbObject.Identifier)) // object with completeName to be dropped
                 .ToList();
         }
-        private void DropDbObjectByName<T>(IEnumerable<T> sourceObjects, IEnumerable<T> destinationObjects, ResultProcessDbObject resultProcessDbObject) where T : DbObject
+
+        private List<T> DropDbObjectByName<T>(IEnumerable<T> sourceObjects, IEnumerable<T> destinationObjects, ResultProcessDbObject resultProcessDbObject) where T : DbObject
+        {
+            var toDrop = DropDbObjectByName(sourceObjects, destinationObjects);
+            resultProcessDbObject.AddOperation<T>(toDrop, Operation.Drop);
+            return toDrop;
+        }
+        private List<T> DropDbObjectByName<T>(IEnumerable<T> sourceObjects, IEnumerable<T> destinationObjects) where T : DbObject
         {
             var toDrop = destinationObjects
                 .Where(dbObject => destinationObjects
@@ -373,7 +383,7 @@ private void DropDbObjectByName<T>(IEnumerable<T> sourceObjects, IEnumerable<T>
                     .OrderBy(x => x).ToList() // list of completeName to be dropped
                     .Contains(dbObject.Name)) // object with completeName to be dropped
                 .ToList();
-            resultProcessDbObject.AddOperation<T>(toDrop, Operation.Drop);
+            return toDrop;
         }        
     }
 }
diff --git a/SqlSchemaCompare.Test/Miscellaneous.cs b/SqlSchemaCompare.Test/Miscellaneous.cs
@@ -0,0 +1,36 @@
+using Shouldly;
+using SqlSchemaCompare.Core.DbStructures;
+using Xunit;
+
+namespace SqlSchemaCompare.Test
+{
+    public class Miscellaneous
+    {
+        [Fact]
+        public void DbObjectEquals_TwoObjectsNull()
+        {
+            DbObject dbObject1 = null;
+            DbObject dbObject2 = null;
+
+            (dbObject1 == dbObject2).ShouldBeTrue();
+        }
+
+        [Fact]
+        public void DbObjectEquals_OneObjectNull()
+        {
+            DbObject dbObject1 = new StoreProcedure();
+            DbObject dbObject2 = null;
+
+            (dbObject2 != dbObject1).ShouldBeTrue();
+            (dbObject1 != dbObject2).ShouldBeTrue();
+        }
+
+        [Fact]
+        public void DbObjectEquals_TwoDifferentObjectsEquals()
+        {
+            DbObject dbObject1 = new StoreProcedure();
+            DbObject dbObject2 = new StoreProcedure();
+            (dbObject1 == dbObject2).ShouldBeTrue();
+        }
+    }
+}
diff --git a/SqlSchemaCompare.Test/TSql/CompareTest.cs b/SqlSchemaCompare.Test/TSql/CompareTest.cs
@@ -28,6 +28,7 @@ CREATE TABLE [dbo].[tbl_Z]([ID] [int] IDENTITY(0,1) NOT NULL)
             errors.ShouldBeEmpty();
             file2.ShouldBeEmpty();
         }
+
         [Fact]
         public void CompareEqualFile()
         {

diff --git a/SqlSchemaCompare.Test/TSql/CreateDatabaseTest.cs b/SqlSchemaCompare.Test/TSql/CreateDatabaseTest.cs
@@ -0,0 +1,98 @@
+using Shouldly;
+using SqlSchemaCompare.Core.Common;
+using SqlSchemaCompare.Core.DbStructures;
+using System.Collections.Generic;
+using Xunit;
+
+namespace SqlSchemaCompare.Test.TSql
+{
+    public class CreateDatabaseTest
+    {
+        private IList<DbObjectType> SelectedObjects;
+        public CreateDatabaseTest()
+        {
+            RelatedDbObjectsConfiguration relatedDbObjectsConfiguration = new();
+            SelectedObjects = relatedDbObjectsConfiguration.GetRelatedDbObjects(DbObjectType.StoreProcedure);
+        }
+
+        [Fact]
+        public void DatabaseEquals_UpdateSchemaIsEmpty()
+        {
+            const string origin =
+@"CREATE DATABASE [db]
+ CONTAINMENT = NONE
+ ON  PRIMARY 
+( NAME = N'db', FILENAME = N'C:\Data\DB.mdf' , SIZE = 1902592KB , MAXSIZE = UNLIMITED, FILEGROWTH = 524288KB )
+ LOG ON 
+( NAME = N'db_log', FILENAME = N'C:\Data\db_log.ldf' , SIZE = 2098432KB , MAXSIZE = 2048GB , FILEGROWTH = 524288KB )
+GO
+
+CREATE PROCEDURE [dbo].[proc]	
+	@par as bit = 0
+AS
+BEGIN
+	SELECT * from [DBO].[TBL1]
+END 
+GO";
+
+            (string updateSchema, string errors) = UtilityTest.UpdateSchema(origin, origin, SelectedObjects);
+
+            updateSchema.ShouldBeEmpty();
+            errors.ShouldBeEmpty();
+        }
+
+        [Fact]
+        public void DatabaseDifferent_UpdateContainsUseStatement()
+        {
+            const string origin =
+@"CREATE DATABASE [db]
+ CONTAINMENT = NONE
+ ON  PRIMARY 
+( NAME = N'db', FILENAME = N'C:\Data\DB.mdf' , SIZE = 1902592KB , MAXSIZE = UNLIMITED, FILEGROWTH = 524288KB )
+ LOG ON 
+( NAME = N'db_log', FILENAME = N'C:\Data\db_log.ldf' , SIZE = 2098432KB , MAXSIZE = 2048GB , FILEGROWTH = 524288KB )
+GO
+
+CREATE PROCEDURE [dbo].[proc]	
+	@par as bit = 0
+AS
+BEGIN
+	SELECT * from [DBO].[TBL]
+END 
+GO";
+            const string destination =
+@"CREATE DATABASE [db]
+ CONTAINMENT = NONE
+ ON  PRIMARY 
+( NAME = N'db', FILENAME = N'C:\Data\DB.mdf' , SIZE = 1902592KB , MAXSIZE = UNLIMITED, FILEGROWTH = 524288KB )
+ LOG ON 
+( NAME = N'db_log', FILENAME = N'C:\Data\db_log.ldf' , SIZE = 2098432KB , MAXSIZE = 2048GB , FILEGROWTH = 524288KB )
+GO
+
+CREATE PROCEDURE [dbo].[proc]	
+	@par as bit = 0
+AS
+BEGIN
+	SELECT * from [DBO].[TBL1]
+END 
+GO";
+
+            (string updateSchema, string errors) = UtilityTest.UpdateSchema(origin, destination, SelectedObjects);
+
+            updateSchema.ShouldBe(
+@"USE [db]
+GO
+
+ALTER PROCEDURE [dbo].[proc]	
+	@par as bit = 0
+AS
+BEGIN
+	SELECT * from [DBO].[TBL]
+END
+GO
+
+");
+            errors.ShouldBeEmpty();
+        }
+    }
+}
diff --git a/SqlSchemaCompare.Test/TSql/ErrorWriterTest.cs b/SqlSchemaCompare.Test/TSql/ErrorWriterTest.cs
@@ -0,0 +1,31 @@
+using Shouldly;
+using SqlSchemaCompare.Core.DbStructures;
+using Xunit;
+
+namespace SqlSchemaCompare.Test.TSql
+{
+    public class ErrorWriterTest
+    {
+        [Fact]
+        public void OrderStatement()
+        {
+            string sql =
+@"CREATE TABLE [dbo].[tbl_Z]([ID] [int] IDENTITY(0,1) NOT NU)
+GO";
+            var (file1, file2, errors) = UtilityTest.Compare(sql, sql, new DbObjectType[] { DbObjectType.Table });
+
+            errors.ShouldBe(
+@"**************** ORIGIN **************** 
+----------------------------------------
+Offending token: NU
+Line: 1, CharPosition: 56
+no viable alternative at input 'NOTNU'
+**************** DESTINATION **************** 
+----------------------------------------
+Offending token: NU
+Line: 1, CharPosition: 56
+no viable alternative at input 'NOTNU'
+");            
+        }
+    }
+}
diff --git a/SqlSchemaCompare.Test/TSql/TSqlIndexTest.cs b/SqlSchemaCompare.Test/TSql/TSqlIndexTest.cs
@@ -130,18 +130,30 @@ public void UpdateSchemaDropDbObject()
             // When present db object in destination absent from origin
             // Expect updateSchema contains drop statement
 
-            const string origin = "CREATE TABLE [dbo].[table] ([ID] [INT] NOT NULL)";
+            const string origin = "CREATE TABLE [dbo].[table] ([ID] [INT] NOT NULL, [ID2] [int] NOT NULL)";
             const string destination =
 @"CREATE DATABASE [dbName]
 GO
 
-CREATE TABLE [dbo].[table] ([ID] [INT] NOT NULL)
+CREATE TABLE [dbo].[table] ([ID] [INT] NOT NULL, [ID2] [int] NOT NULL)
 GO
 
 CREATE NONCLUSTERED INDEX [indexName] ON [dbo].[table]
 (
 	[ID] ASC
 )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [indexTable]
+GO
+
+ALTER INDEX [indexName] on [dbo].[table] DISABLE
+GO
+
+CREATE NONCLUSTERED INDEX [indexName2] ON [dbo].[table]
+(
+	[ID2] ASC
+) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [indexTable]
+GO
+
+ALTER INDEX [indexName2] on [dbo].[table] DISABLE
 GO";
 
             (string updateSchema, string errors) = UtilityTest.UpdateSchema(origin, destination, SelectedObjects);
@@ -153,6 +165,9 @@ [ID] ASC
 DROP INDEX [indexName] ON [dbo].[table]
 GO
 
+DROP INDEX [indexName2] ON [dbo].[table]
+GO
+
 ");
             errors.ShouldBeEmpty();
         }

diff --git a/SqlSchemaCompare.Test/UtilityTest.cs b/SqlSchemaCompare.Test/UtilityTest.cs
@@ -2,9 +2,7 @@
 using SqlSchemaCompare.Core.Common;
 using SqlSchemaCompare.Core.DbStructures;
 using SqlSchemaCompare.Core.TSql;
-using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace SqlSchemaCompare.Test
 {

diff --git a/SqlSchemaCompare.WindowsForm/SqlSchemaCompare.WindowsForm.csproj b/SqlSchemaCompare.WindowsForm/SqlSchemaCompare.WindowsForm.csproj
@@ -11,7 +11,7 @@
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <SignAssembly>true</SignAssembly>
     <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
-    <Version>1.0.20</Version>
+    <Version>1.0.21</Version>
   </PropertyGroup>
 
   <ItemGroup>
-Original file line number
+Diff line change
@@ Expand Up / @@ -28,6 +28,7 @@ CREATE TABLE [dbo].[tbl_Z]([ID] [int] IDENTITY(0,1) NOT NULL) @@
                 errors.ShouldBeEmpty();
                 file2.ShouldBeEmpty();
             }
             [Fact]
             public void CompareEqualFile()
             {
@@ Expand Down @@