- Fixed a Bug where Identity Column Value was not correctly synced after Materialization Process is completing.

- Added new Helper API to quickly Sync the Identity column value with the current MAX Id value of the column (ensuring it's valid after populating additional data); This is useful if you override Identity values for a full Table refresh, but then want to later insert data into the table.

Author: cajuncoding

NetStandard.SqlBulkHelpers/MaterializedData/MaterializeDataContext.cs

@@ -194,6 +194,12 @@ public async Task FinishMaterializeDataProcessAsync()
                 var liveTableDefinition = materializationTableInfo.LiveTableDefinition;
                 var otherReferencingFKeyConstraints = liveTableDefinition.ReferencingForeignKeyConstraints.Where(rc => !allLiveTableFKeyConstraintLookup.Contains(rc.ToString()));
 
+                //FIRST handle Identity values to minimize risk of Changes.
+                //If Enabled then we Automatically Sync the Identity Value of the newly switched Live table with the Max ID so that is is guaranteed to be a valid value
+                //  otherwise (if disabled) then the Identity may not change when Materializing data...
+                if (BulkHelpersConfig.IsCloningIdentitySeedValueEnabled && liveTableDefinition.IdentityColumn != null)
+                    switchScriptBuilder.SyncIdentitySeedValue(materializationTableInfo.LoadingTable, materializationTableInfo.LiveTable);
+
                 switchScriptBuilder
                     //HERE We enable all FKey Constraints and Trigger a Re-check to ensure Data Integrity (unless EXPLICITLY Overridden)!
                     //NOTE: This is critical because the FKeys were added with NOCHECK status above so that we could safely switch
@@ -205,6 +211,7 @@ public async Task FinishMaterializeDataProcessAsync()
                     //Finally cleanup the Loading and Discarding tables...
                     .DropTable(materializationTableInfo.LoadingTable)
                     .DropTable(materializationTableInfo.DiscardingTable);
+
             }
 
             //var timeoutConvertedToMinutes = Math.Max(1, (int)Math.Ceiling((decimal)BulkHelpersConfig.MaterializeDataStructureProcessingTimeoutSeconds / 60));

NetStandard.SqlBulkHelpers/MaterializedData/MaterializeDataHelper.cs

@@ -320,7 +320,7 @@ public async Task<TableNameTerm[]> ClearTablesAsync(SqlTransaction sqlTransactio
                         lock (tablesToMaterializeAsEmpty) tablesToMaterializeAsEmpty.Add(tableNameTerm);
                     else
                         lock (tablesToProcessWithTruncation) tablesToProcessWithTruncation.Add(tableNameTerm);
-                };
+                }
 
                 if (tablesToMaterializeAsEmpty.Any())
                 {
@@ -405,7 +405,7 @@ public long GetTableCurrentIdentityValue(SqlConnection sqlConnection, SqlTransac
         private SqlCommand CreateGetTableIdentityValueSqlCommand(SqlConnection sqlConnection, SqlTransaction sqlTransaction = null, string tableNameOverride = null)
         {
             var fullyQualifiedTableName = GetMappedTableNameTerm(tableNameOverride).FullyQualifiedTableName;
-            var sqlCmd = new SqlCommand("SELECT CURRENT_IDENTITY_VALUE = IDENT_CURRENT(@TableName)", sqlConnection, sqlTransaction);
+            var sqlCmd = new SqlCommand("SELECT CURRENT_IDENTITY_VALUE = IDENT_CURRENT(@TableName);", sqlConnection, sqlTransaction);
             sqlCmd.CommandTimeout = BulkHelpersConfig.MaterializeDataStructureProcessingTimeoutSeconds;
             sqlCmd.Parameters.Add("@TableName", SqlDbType.NVarChar).Value = fullyQualifiedTableName;
             return sqlCmd;
@@ -453,6 +453,55 @@ private SqlCommand CreateReSeedTableIdentityValueSqlCommand(SqlConnection sqlCon
             return sqlCmd;
         }
 
+        /// <summary>
+        /// Sets / Re-seeds the Current Identity Value with the current MAX() value of the Identity Column for the specified Table.
+        /// </summary>
+        /// <param name="sqlConnection"></param>
+        /// <param name="sqlTransaction"></param>
+        /// <param name="tableNameOverride"></param>
+        /// <returns></returns>
+        public async Task<long> ReSeedTableIdentityValueWithMaxIdAsync(SqlConnection sqlConnection, SqlTransaction sqlTransaction = null, string tableNameOverride = null)
+        {
+            var tableDef = await GetTableSchemaDefinitionInternalAsync(TableSchemaDetailLevel.BasicDetails, sqlConnection, sqlTransaction: sqlTransaction, tableNameOverride).ConfigureAwait(false);
+            using (var sqlCmd = CreateReSeedTableIdentityValueToSyncWithMaxIdSqlCommand(sqlConnection, tableDef, sqlTransaction))
+            {
+                var result = await sqlCmd.ExecuteScalarAsync().ConfigureAwait(false);
+                return Convert.ToInt64(result);
+            }
+        }
+
+        /// <summary>
+        /// Sets / Re-seeds the Current Identity Value with the current MAX() value of the Identity Column for the specified Table.
+        /// </summary>
+        /// <param name="sqlConnection"></param>
+        /// <param name="sqlTransaction"></param>
+        /// <param name="tableNameOverride"></param>
+        /// <returns></returns>
+        public long ReSeedTableIdentityWithMaxId(SqlConnection sqlConnection, SqlTransaction sqlTransaction = null, string tableNameOverride = null)
+        {
+            var tableDef = GetTableSchemaDefinitionInternal(TableSchemaDetailLevel.BasicDetails, sqlConnection, sqlTransaction: sqlTransaction, tableNameOverride);
+            using (var sqlCmd = CreateReSeedTableIdentityValueToSyncWithMaxIdSqlCommand(sqlConnection, tableDef, sqlTransaction))
+            {
+                var result = sqlCmd.ExecuteScalar();
+                return Convert.ToInt64(result);
+            }
+        }
+
+        private SqlCommand CreateReSeedTableIdentityValueToSyncWithMaxIdSqlCommand(SqlConnection sqlConnection, SqlBulkHelpersTableDefinition tableDef, SqlTransaction sqlTransaction = null)
+        {
+            var tableNameTerm = tableDef.TableNameTerm;
+            var maxIdVariable = $"@MaxId_{tableNameTerm.TableNameVariable}";
+
+            var sqlCmd = new SqlCommand($@"
+                DECLARE {maxIdVariable} BIGINT = (SELECT MAX({tableDef.IdentityColumn.ColumnName.QualifySqlTerm()}) FROM {tableNameTerm.FullyQualifiedTableName});
+                DBCC CHECKIDENT(@TableName, RESEED, {maxIdVariable});
+                SELECT CURRENT_IDENTITY_VALUE = IDENT_CURRENT(@TableName);
+            ", sqlConnection, sqlTransaction);
+            
+            sqlCmd.CommandTimeout = BulkHelpersConfig.MaterializeDataStructureProcessingTimeoutSeconds;
+            sqlCmd.Parameters.Add("@TableName", SqlDbType.NVarChar).Value = tableNameTerm.FullyQualifiedTableName;
+            return sqlCmd;
+        }
 
         #endregion
 

NetStandard.SqlBulkHelpers/MaterializedData/MaterializedDataScriptBuilder.cs

@@ -164,7 +164,7 @@ public MaterializedDataScriptBuilder SyncIdentitySeedValue(TableNameTerm sourceT
 
             //Variables will be written out at the Top of the Script so they are initialized quickly and values used are consistent for the entire script...
             var currentIdentityVariable = $"@CurrentIdentity_{sourceTable.TableNameVariable}";
-            Variables.TryAdd(currentIdentityVariable, $"DECLARE {currentIdentityVariable} int = IDENT_CURRENT('{sourceTable.FullyQualifiedTableName}');");
+            Variables.TryAdd(currentIdentityVariable, $"DECLARE {currentIdentityVariable} BIGINT = IDENT_CURRENT('{sourceTable.FullyQualifiedTableName}');");
 
             ScriptBuilder.Append($@"
 	            --Syncs the Identity Seed value of the Target Table with the current value of the Source Table (captured into Variable at top of script)

NetStandard.SqlBulkHelpers/MaterializedData/MaterializedDataSqlClientExtensionsApi.cs

@@ -285,7 +285,7 @@ private static async Task ReSeedTableIdentityValueInternalAsync<T>(
 
 
         public static void ReSeedTableIdentityValue(this SqlTransaction sqlTransaction, string tableName, long newIdentitySeedValue, ISqlBulkHelpersConfig bulkHelpersConfig = null)
-            => ReSeedTableIdentityValueAsync<ISkipMappingLookup>(sqlTransaction, newIdentitySeedValue, tableName, bulkHelpersConfig);
+            => ReSeedTableIdentityValue<ISkipMappingLookup>(sqlTransaction, newIdentitySeedValue, tableName, bulkHelpersConfig);
 
         public static void ReSeedTableIdentityValue<T>(this SqlTransaction sqlTransaction, long newIdentitySeedValue, string tableNameOverride = null, ISqlBulkHelpersConfig bulkHelpersConfig = null)
             where T : class
@@ -309,6 +309,57 @@ private static void ReSeedTableIdentityValueInternal<T>(
             new MaterializeDataHelper<T>(bulkHelpersConfig).ReSeedTableIdentityValue(sqlConnection, newIdentitySeedValue, sqlTransaction, tableNameOverride);
         }
 
+        public static Task<long> ReSeedTableIdentityValueWithMaxIdAsync(this SqlTransaction sqlTransaction, string tableName, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            => ReSeedTableIdentityValueWithMaxIdAsync<ISkipMappingLookup>(sqlTransaction, tableName, bulkHelpersConfig);
+
+        public static Task<long> ReSeedTableIdentityValueWithMaxIdAsync<T>(this SqlTransaction sqlTransaction, string tableNameOverride = null, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            where T : class
+        {
+            sqlTransaction.AssertArgumentIsNotNull(nameof(sqlTransaction));
+            return ReSeedTableIdentityValueWithMaxIdInternalAsync<T>(sqlTransaction.Connection, tableNameOverride, sqlTransaction, bulkHelpersConfig);
+        }
+
+        public static Task<long> ReSeedTableIdentityValueWithMaxIdAsync(this SqlConnection sqlConnection, string tableName, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            => ReSeedTableIdentityValueWithMaxIdInternalAsync<ISkipMappingLookup>(sqlConnection, tableName, bulkHelpersConfig: bulkHelpersConfig);
+
+        private static async Task<long> ReSeedTableIdentityValueWithMaxIdInternalAsync<T>(
+            this SqlConnection sqlConnection,
+            string tableNameOverride = null,
+            SqlTransaction sqlTransaction = null,
+            ISqlBulkHelpersConfig bulkHelpersConfig = null
+        ) where T : class
+        {
+            sqlConnection.AssertArgumentIsNotNull(nameof(sqlConnection));
+
+            return await new MaterializeDataHelper<T>(bulkHelpersConfig)
+                .ReSeedTableIdentityValueWithMaxIdAsync(sqlConnection, sqlTransaction, tableNameOverride)
+                .ConfigureAwait(false);
+        }
+
+        public static long ReSeedTableIdentityValueWithMaxId(this SqlTransaction sqlTransaction, string tableName, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            => ReSeedTableIdentityValueWithMaxId<ISkipMappingLookup>(sqlTransaction, tableName, bulkHelpersConfig);
+
+        public static long ReSeedTableIdentityValueWithMaxId<T>(this SqlTransaction sqlTransaction, string tableNameOverride = null, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            where T : class
+        {
+            sqlTransaction.AssertArgumentIsNotNull(nameof(sqlTransaction));
+            return ReSeedTableIdentityValueWithMaxIdInternal<T>(sqlTransaction.Connection, tableNameOverride, sqlTransaction, bulkHelpersConfig);
+        }
+
+        public static long ReSeedTableIdentityValueWithMaxId(this SqlConnection sqlConnection, string tableName, ISqlBulkHelpersConfig bulkHelpersConfig = null)
+            => ReSeedTableIdentityValueWithMaxIdInternal<ISkipMappingLookup>(sqlConnection, tableName, bulkHelpersConfig: bulkHelpersConfig);
+
+        private static long ReSeedTableIdentityValueWithMaxIdInternal<T>(
+            this SqlConnection sqlConnection,
+            string tableNameOverride = null,
+            SqlTransaction sqlTransaction = null,
+            ISqlBulkHelpersConfig bulkHelpersConfig = null
+        ) where T : class
+        {
+            sqlConnection.AssertArgumentIsNotNull(nameof(sqlConnection));
+            return new MaterializeDataHelper<T>(bulkHelpersConfig).ReSeedTableIdentityWithMaxId(sqlConnection, sqlTransaction, tableNameOverride);
+        }
+
         #endregion
 
         #region Full Text Index (cannot be altered within a Transaction)...

NetStandard.SqlBulkHelpers/NetStandard.SqlBulkHelpers.csproj

@@ -8,23 +8,26 @@
 	<PackageLicenseExpression>MIT</PackageLicenseExpression>
     <Authors>BBernard / CajunCoding</Authors>
     <Company>CajunCoding</Company>
+	<Version>2.2.3</Version>
 	<PackageProjectUrl>https://github.com/cajuncoding/SqlBulkHelpers</PackageProjectUrl>
 	<RepositoryUrl>https://github.com/cajuncoding/SqlBulkHelpers</RepositoryUrl>
     <Description>A library for easy, efficient and high performance bulk insert and update of data, into a Sql Database, from .Net applications. By leveraging the power of the SqlBulkCopy classes with added support for Identity primary key table columns this library provides a greatly simplified interface to process Identity based Entities with Bulk Performance with the wide compatibility of .NetStandard 2.0.</Description>
 	<PackageTags>sql server database table bulk insert update identity column sqlbulkcopy orm dapper linq2sql materialization materialized data view materialized-data materialized-view sync replication replica readonly</PackageTags>
     <PackageReleaseNotes>
+		- Fixed a Bug where Identity Column Value was not correctly synced after Materialization Process is completing.
+		- Added new Helper API to quickly Sync the Identity column value with the current MAX Id value of the column (ensuring it's valid after populating additional data); This is useful if you override Identity values for a full Table refresh, but then want to later insert data into the table.
+
+	    Prior Relese Notes:
 		- Improved namespace for SqlBulkHelpers.CustomExtensions to reduce risk of conflicts with similar existing extensions.
-	    - Restored support for SqlConnection Factory (simplified now as a Func&lt;SqlConnection&gt; when manually using the SqlDbSchemaLoader to dynamically retrieve Table Schema definitions for performance.
-	    - Added support for other Identity column data types including (INT, BIGINT, SMALLINT, &amp; TINYINT); per feature request (https://github.com/cajuncoding/SqlBulkHelpers/issues/10).
+		- Restored support for SqlConnection Factory (simplified now as a Func&lt;SqlConnection&gt; when manually using the SqlDbSchemaLoader to dynamically retrieve Table Schema definitions for performance.
+		- Added support for other Identity column data types including (INT, BIGINT, SMALLINT, &amp; TINYINT); per feature request (https://github.com/cajuncoding/SqlBulkHelpers/issues/10).
 		- Added support to explicitly set Identity Values (aka SET IDENTITY_INSERT ON) via new `enableIdentityInsert` api parameter.
 		- Added support to retreive and re-seed (aka set) the current Identity Value on a given table via new apis in the MaterializedData helpers.
 		- Additional small bug fixes and optimiaztions.
-
-		Prior Relese Notes:
 	    - Added additional convenience methods to the `MaterializationContext` to retreive loading table info for models mapped via annotations (ModelType; vs only ordinal or string name).
-	    - Added support to cancel the materialization process via new `MaterializationContext.CancelMaterializationProcess()` method; allows passive cancelling without the need to throw an exception to safely stop the process.
-	    - Fixed small configuration initialization bugs when manually setting the `IsFullTextIndexHandlingEnabled` flag.
-	    - Fixed small bug where default configuration was not being used as the fallback.
+		- Added support to cancel the materialization process via new `MaterializationContext.CancelMaterializationProcess()` method; allows passive cancelling without the need to throw an exception to safely stop the process.
+		- Fixed small configuration initialization bugs when manually setting the `IsFullTextIndexHandlingEnabled` flag.
+		- Fixed small bug where default configuration was not being used as the fallback.
 		- Improve configuration of Timeouts and add support for Default DB Schema Loader timeout setting.
 		- v2.0 provides a simplified and easier to access API as Extension Methods of the SqlTransaction class; this is a breaking change for Sql Bulk Insert/Update/etc, but shoudl be easy to migrate to!
 		- v2.0 release also includes the NEW MaterializeData Helpers to make it significantly easier to implement highly efficient loading and publishing of materialized data via Sql Server much easier via an easy C# API.
@@ -49,7 +52,6 @@
 		- Added more Integration Tests for Constructors and Connections, as well as the new DB Schema Loader caching implementation.
 		- Fixed bug in dynamic initialization of SqlBulkHelpersConnectionProvider and SqlBulkHelpersDBSchemaLoader when not using the Default instances that automtically load the connection string from the application configuration setting.
 	</PackageReleaseNotes>
-    <Version>2.2.2</Version>
   </PropertyGroup>
 
   <ItemGroup>

NetStandard.SqlBulkHelpers/SqlBulkHelpersConfig.cs

@@ -53,7 +53,7 @@ public static void ConfigureDefaults(Action<SqlBulkHelpersConfig> configAction)
         {
             DefaultConfig = Create(configAction);
 
-            //Validate tje Configuration!
+            //Validate the Configuration!
             if (DefaultConfig.IsFullTextIndexHandlingEnabled && !DefaultConfig.IsConcurrentConnectionProcessingEnabled)
                 throw new InvalidOperationException(
                 $"Full Text Index Handling is currently enabled however Concurrent Connections are disabled and/or " +