Add the support to retrieve the seed/increment for the IDENTITY column (fixes #10).

Author: GillesTourreau

src/Testing.Databases.SqlServer/Comparer/SqlObjectComparer.cs

@@ -6,6 +6,8 @@
 
 namespace PosInformatique.Testing.Databases.SqlServer
 {
+    using System.Diagnostics.CodeAnalysis;
+
     internal sealed class SqlObjectComparer : ISqlObjectVisitor<SqlObjectDifferences?>
     {
         private readonly SqlObject source;
@@ -73,7 +75,7 @@ public static IList<SqlTableDifferences> Compare(IReadOnlyList<SqlTable> source,
                 this.CompareProperty(column, t => t.Precision, nameof(column.Precision)),
                 this.CompareProperty(column, t => t.Scale, nameof(column.Scale)),
                 this.CompareProperty(column, t => t.IsNullable, nameof(column.IsNullable)),
-                this.CompareProperty(column, t => t.IsIdentity, nameof(column.IsIdentity)),
+                this.CompareProperty(column, t => t.Identity, nameof(column.Identity), equalityComparer: SqlColumnIdentityComparer.Instance),
                 this.CompareProperty(column, t => t.CollationName, nameof(column.CollationName)),
                 this.CompareProperty(column, t => t.IsComputed, nameof(column.IsComputed)),
                 this.CompareProperty(column, t => TsqlCodeHelper.RemoveNotUsefulCharacters(t.ComputedExpression), nameof(column.ComputedExpression), t => t.ComputedExpression));
@@ -331,7 +333,7 @@ private static IReadOnlyList<SqlObjectPropertyDifference> GetPropertyDifferences
             return objects.SingleOrDefault(o => Equals(keySelector(o), value));
         }
 
-        private SqlObjectPropertyDifference? CompareProperty<TSqlObject>(TSqlObject target, Func<TSqlObject, object?> propertyValueForComparison, string name, Func<TSqlObject, object?>? propertyValueToDisplay = null)
+        private SqlObjectPropertyDifference? CompareProperty<TSqlObject, TProperty>(TSqlObject target, Func<TSqlObject, TProperty?> propertyValueForComparison, string name, Func<TSqlObject, TProperty?>? propertyValueToDisplay = null, IEqualityComparer<TProperty?>? equalityComparer = null)
             where TSqlObject : SqlObject
         {
             var source = (TSqlObject)this.source;
@@ -344,7 +346,12 @@ private static IReadOnlyList<SqlObjectPropertyDifference> GetPropertyDifferences
             var sourceValue = propertyValueForComparison(source);
             var targetValue = propertyValueForComparison(target);
 
-            if (!Equals(sourceValue, targetValue))
+            if (equalityComparer is null)
+            {
+                equalityComparer = EqualityComparer<TProperty?>.Default;
+            }
+
+            if (!equalityComparer.Equals(sourceValue, targetValue))
             {
                 return new SqlObjectPropertyDifference(name, propertyValueToDisplay(source), propertyValueToDisplay(target));
             }
@@ -364,5 +371,50 @@ private static IReadOnlyList<SqlObjectPropertyDifference> GetPropertyDifferences
 
             return new SqlObjectDifferences<TSqlObject>((TSqlObject)this.source, target, SqlObjectDifferenceType.Different, properties!);
         }
+
+        private sealed class SqlColumnIdentityComparer : IEqualityComparer<SqlColumnIdentity?>
+        {
+            private SqlColumnIdentityComparer()
+            {
+            }
+
+            public static SqlColumnIdentityComparer Instance { get; } = new SqlColumnIdentityComparer();
+
+            public bool Equals(SqlColumnIdentity? x, SqlColumnIdentity? y)
+            {
+                if (x is null)
+                {
+                    if (y is null)
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                if (y is null)
+                {
+                    return false;
+                }
+
+                if (x.Seed != y.Seed)
+                {
+                    return false;
+                }
+
+                if (x.Increment != y.Increment)
+                {
+                    return false;
+                }
+
+                return true;
+            }
+
+            [ExcludeFromCodeCoverage]
+            public int GetHashCode(SqlColumnIdentity? obj)
+            {
+                throw new NotImplementedException();
+            }
+        }
     }
 }

src/Testing.Databases.SqlServer/ObjectModel/SqlColumn.cs

@@ -70,7 +70,7 @@ internal SqlColumn(
         /// <summary>
         /// Gets a value indicating whether if the column is identity.
         /// </summary>
-        public bool IsIdentity { get; internal set; }
+        public SqlColumnIdentity? Identity { get; internal set; }
 
         /// <summary>
         /// Gets a value indicating whether if the column is computed.

src/Testing.Databases.SqlServer/ObjectModel/SqlColumnIdentity.cs

@@ -0,0 +1,42 @@
+//-----------------------------------------------------------------------
+// <copyright file="SqlColumnIdentity.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Testing.Databases
+{
+    /// <summary>
+    /// Represents the <see cref="SqlColumn.Identity"/> information when
+    /// a <see cref="SqlColumn"/> is an <c>IDENTITY</c> column.
+    /// </summary>
+    public class SqlColumnIdentity
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SqlColumnIdentity"/> class.
+        /// </summary>
+        /// <param name="seed">Seed of the <c>IDENTITY</c> column.</param>
+        /// <param name="increment">Increment of the <c>IDENTITY</c> column.</param>
+        public SqlColumnIdentity(int seed, int increment)
+        {
+            this.Seed = seed;
+            this.Increment = increment;
+        }
+
+        /// <summary>
+        /// Gets the seed of the <c>IDENTITY</c> column.
+        /// </summary>
+        public int Seed { get; }
+
+        /// <summary>
+        /// Gets the increment of the <c>IDENTITY</c> column.
+        /// </summary>
+        public int Increment { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"(Seed: {this.Seed}, Increment: {this.Increment})";
+        }
+    }
+}

src/Testing.Databases.SqlServer/SqlServerDatabaseObjectExtensions.cs

@@ -298,13 +298,18 @@ private static async Task<ILookup<int, DataRow>> GetColumnsAsync(SqlServerDataba
 	                [c].[collation_name] AS [CollationName],
 	                [c].[is_nullable] AS [IsNullable],
 	                [c].[is_identity] AS [IsIdentity],
+                    [ic].[seed_value] AS [IdentitySeed],
+                    [ic].[increment_value] AS [IdentityIncrement],
 	                [c].[is_computed] AS [IsComputed],
 	                [cc].[definition] AS [ComputedExpression]
                 FROM
 	                [sys].[columns] AS [c]
 		                LEFT OUTER JOIN
 	                [sys].[computed_columns] AS [cc]
-		                ON ([c].[object_id] = [cc].[object_id] AND [c].[column_id] = [cc].[column_id]),
+		                ON ([c].[object_id] = [cc].[object_id] AND [c].[column_id] = [cc].[column_id])
+                        LEFT OUTER JOIN
+	                [sys].[identity_columns] AS [ic]
+		                ON ([c].[object_id] = [ic].[object_id] AND [c].[column_id] = [ic].[column_id]),
 	                [sys].[tables] AS [t],
 	                [sys].[types] AS [ty]
                 WHERE
@@ -500,6 +505,13 @@ private static SqlCheckConstraint ToCheckConstraint(DataRow row)
 
         private static SqlColumn ToColumn(DataRow row, DataRow? defaultConstraintRow)
         {
+            SqlColumnIdentity? identity = null;
+
+            if ((bool)row["IsIdentity"] == true)
+            {
+                identity = new SqlColumnIdentity((int)row["IdentitySeed"], (int)row["IdentityIncrement"]);
+            }
+
             return new SqlColumn(
                 (string)row["Name"],
                 Convert.ToInt32(row["Position"], CultureInfo.InvariantCulture),
@@ -512,7 +524,7 @@ private static SqlColumn ToColumn(DataRow row, DataRow? defaultConstraintRow)
                 ComputedExpression = NullIfDbNull<string>(row["ComputedExpression"]),
                 DefaultConstraint = defaultConstraintRow != null ? ToDefaultConstraint(defaultConstraintRow) : null,
                 IsComputed = (bool)row["IsComputed"],
-                IsIdentity = (bool)row["IsIdentity"],
+                Identity = identity,
                 IsNullable = (bool)row["IsNullable"],
             };
         }

tests/Testing.Databases.SqlServer.Tests.Source/Tables/TableDifference.sql

@@ -5,7 +5,7 @@
 	[MaxLength]	VARCHAR(50) NOT NULL,
 	[Precision]	DECIMAL(10, 2) NOT NULL,
 	[Scale]		DECIMAL(10, 2) NOT NULL,
-	[Identity]	INT NOT NULL IDENTITY,
+	[Identity]	INT NOT NULL IDENTITY (2, 3),
 	[ForeignKeyId] INT NULL,
     [Computed]  AS [Scale] + [Precision],
     [SourceColumn] INT NOT NULL,

tests/Testing.Databases.SqlServer.Tests.Source/Tables/TableIdentical.sql

@@ -1,6 +1,6 @@
 CREATE TABLE [dbo].[TableIdentical]
 (
-	[Id] INT NOT NULL,
+	[Id] INT IDENTITY (4, 5) NOT NULL,
 	[ForeignKeyId] INT NOT NULL CONSTRAINT DF_TableIdentical_ForeignKeyId DEFAULT (1 + 2 + 3),
 	[IncludeColumn] INT NOT NULL,
 )

tests/Testing.Databases.SqlServer.Tests.Source/Tables/TableWithDifferentPrimaryKey.sql

@@ -1,6 +1,6 @@
 CREATE TABLE [dbo].[TableWithDifferentPrimaryKey]
 (
-	[Id] INT NOT NULL,
+	[Id] INT IDENTITY (10, 20) NOT NULL,
 
 	CONSTRAINT [PK_TableWithDifferentPrimaryKey_Source] PRIMARY KEY CLUSTERED ([Id] ASC)
 )

tests/Testing.Databases.SqlServer.Tests.Target/Tables/TableWithDifferentPrimaryKey.sql

@@ -1,6 +1,6 @@
 CREATE TABLE [dbo].[TableWithDifferentPrimaryKey]
 (
-	[Id] INT NOT NULL,
+	[Id] INT IDENTITY (1, 2) NOT NULL,
 
 	CONSTRAINT [PK_TableWithDifferentPrimaryKey_Target] PRIMARY KEY CLUSTERED ([Id] ASC)
 )

tests/Testing.Databases.SqlServer.Tests/ObjectModel/SqlColumnIdentityTest.cs

@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------
+// <copyright file="SqlColumnIdentityTest.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Testing.Databases.Tests
+{
+    public class SqlColumnIdentityTest
+    {
+        [Fact]
+        public void ToStringTest()
+        {
+            var column = new SqlColumnIdentity(1, 2);
+
+            column.ToString().Should().Be("(Seed: 1, Increment: 2)");
+        }
+    }
+}

tests/Testing.Databases.SqlServer.Tests/SqlServerDatabaseComparerTest.CompareAsync.txt

@@ -42,9 +42,9 @@
         Source: 2
         Target: 4
   - Identity
-    * IsIdentity:
-        Source: True
-        Target: False
+    * Identity:
+        Source: (Seed: 2, Increment: 3)
+        Target: <No value>
   - Computed
     * Scale:
         Source: 2
@@ -166,6 +166,11 @@
           Target: 2
 - dbo.TableTarget (Missing in the source)
 - dbo.TableWithDifferentPrimaryKey
+  ------ Columns ------
+  - Id
+    * Identity:
+        Source: (Seed: 10, Increment: 20)
+        Target: (Seed: 1, Increment: 2)
   ------ Indexes ------
   - PK_TableWithDifferentPrimaryKey_Target (Missing in the source)
   - PK_TableWithDifferentPrimaryKey_Source (Missing in the target)