Added test to allow for direct BulkCopy with no batching

Author: Jason Valdez

src/IntegrationTests/BulkLoading/BulkLoaderForBatchSizeTests.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Data.SqlClient;
-using System.Linq;
+using System.Linq;
 using FluentAssertions;
 using ivaldez.Sql.IntegrationTests.Data;
 using ivaldez.Sql.SqlBulkLoader;
@@ -10,28 +8,6 @@ namespace ivaldez.Sql.IntegrationTests.BulkLoading
 {
     public class BulkLoaderForBatchSizeTests
     {
-        public class SqlBulkCopyUtilitySpy: BulkLoader.ISqlBulkCopyUtility
-        {
-            public void BulkCopy<T>(string tableName,
-                SqlConnection conn, 
-                SqlBulkCopyOptions options,
-                BulkLoader.TargetProperty[] targetProperties,
-                IEnumerable<T> toInsert)
-            {
-                BulkCopyCalled++;
-
-                new BulkLoader.SqlBulkCopyUtility()
-                    .BulkCopy(tableName,
-                        conn, 
-                        options,
-                        targetProperties,
-                        toInsert);
-            }
-
-            public int BulkCopyCalled { get; set; }
-        }
-
-
         [Fact]
         public void ShouldBatchBulkCopyCommandsByOptionValue()
         {

src/IntegrationTests/BulkLoading/BulkLoaderForNoBatchTests.cs

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using FluentAssertions;
+using ivaldez.Sql.IntegrationTests.Data;
+using ivaldez.Sql.SqlBulkLoader;
+using Xunit;
+
+namespace ivaldez.Sql.IntegrationTests.BulkLoading
+{
+    public class BulkLoaderForNoBatchTests
+    {
+        [Fact]
+        public void ShouldNotBatchWhenOptionSelected()
+        {
+            var testingDatabaseService = new TestingDatabaseService();
+            testingDatabaseService.CreateTestDatabase();
+
+            var dataGateway = new TestingDataGateway(testingDatabaseService);
+
+            dataGateway.DropTable();
+            dataGateway.CreateSingleSurrogateKeyTable();
+
+            var dtos = new[]
+            {
+                new SampleSurrogateKey
+                {
+                    Pk = 100,
+                    TextValue = "JJ",
+                    IntValue = 100,
+                    DecimalValue = 100.99m
+                },
+                new SampleSurrogateKey
+                {
+                    Pk = 200,
+                    TextValue = "ZZ",
+                    IntValue = 999,
+                    DecimalValue = 123.45m
+                }
+            };
+
+            var sqlBulkCopyUtilitySpy = new SqlBulkCopyUtilitySpy();
+            
+            dataGateway.ExecuteWithConnection(conn =>
+            {
+                new BulkLoader(sqlBulkCopyUtilitySpy)
+                    .InsertWithOptions("Sample", conn, true, dtos)
+                    .SetBatchSize(1)
+                    .NoBatch()
+                    .Execute();
+            });
+
+            sqlBulkCopyUtilitySpy.BulkCopyCalled.Should().Be(1);
+
+            var databaseDtos = dataGateway.GetAllSampleSurrogateKey().ToArray();
+
+            var firstDto = databaseDtos.First(x => x.TextValue == "JJ");
+            firstDto.IntValue.Should().Be(100);
+            firstDto.DecimalValue.Should().Be(100.99m);
+
+            var secondDto = databaseDtos.First(x => x.TextValue == "ZZ");
+            secondDto.IntValue.Should().Be(999);
+            secondDto.DecimalValue.Should().Be(123.45m);
+        }
+    }
+}

src/IntegrationTests/BulkLoading/SqlBulkCopyUtilitySpy.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using ivaldez.Sql.SqlBulkLoader;
+
+namespace ivaldez.Sql.IntegrationTests.BulkLoading
+{
+    public class SqlBulkCopyUtilitySpy: BulkLoader.ISqlBulkCopyUtility
+    {
+        public void BulkCopy<T>(string tableName,
+            SqlConnection conn, 
+            SqlBulkCopyOptions options,
+            BulkLoader.TargetProperty[] targetProperties,
+            IEnumerable<T> toInsert)
+        {
+            BulkCopyCalled++;
+
+            new BulkLoader.SqlBulkCopyUtility()
+                .BulkCopy(tableName,
+                    conn, 
+                    options,
+                    targetProperties,
+                    toInsert);
+        }
+
+        public int BulkCopyCalled { get; set; }
+    }
+}

src/IntegrationTests/IntegrationTests.csproj

@@ -68,10 +68,12 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BulkLoading\BulkLoaderForNoBatchTests.cs" />
     <Compile Include="BulkLoading\BulkLoaderForBatchSizeTests.cs" />
     <Compile Include="BulkLoading\BulkLoaderForFieldOptionsTests.cs" />
     <Compile Include="BulkLoading\BulkLoaderForPrimaryKeyTests.cs" />
     <Compile Include="BulkLoading\BulkLoaderGeneralTests.cs" />
+    <Compile Include="BulkLoading\SqlBulkCopyUtilitySpy.cs" />
     <Compile Include="Data\SampleSurrogateKeyDifferentNamesDto.cs" />
     <Compile Include="Data\TestingDatabaseService.cs" />
     <Compile Include="Data\TestingDataGateway.cs" />

src/ivaldez.SqlBulkLoader/BulkLoader.cs

@@ -55,13 +55,15 @@ public BulkLoaderContext<T> InsertWithOptions<T>(
         /// <param name="conn">A SQL connection</param>
         /// <param name="keepIdentityColumnValue">If true, the bulk copy will attempt to insert into identity columns on the target table.</param>
         /// <param name="dataToInsert">The data that will be bulk loaded into the target table.</param>
-        /// <param name="batchSize">The batch size of each bulk load.</param>
+        /// <param name="batchSize">The batch size of each bulk load.</param> 
+        /// <param name="noBatch">Indicates that no batching should occur and all data should be written at once.</param>
         public void Insert<T>(
             string tableName,
             SqlConnection conn,
             bool keepIdentityColumnValue,
             IEnumerable<T> dataToInsert,
-            int batchSize = 5000)
+            int batchSize = 5000,
+            bool noBatch = false)
         {
             Insert(
                 tableName,
@@ -70,7 +72,8 @@ public void Insert<T>(
                 dataToInsert,
                 new List<string>(),
                 new Dictionary<string, string>(),
-                batchSize);
+                batchSize,
+                noBatch);
         }
 
         /// <summary>
@@ -84,24 +87,44 @@ public void Insert<T>(
         /// <param name="propertiesToIgnore">A list of properties on the DTO to ignore.</param>
         /// <param name="renameFields">Pairs of source property names and mapped column names on the target table.</param>
         /// <param name="batchSize">The batch size of each bulk load.</param>
-        public void Insert<T>(
-            string tableName,
+        /// <param name="noBatch">Indicates that no batching should occur and all data should be written at once.</param>
+        public void Insert<T>(string tableName,
             SqlConnection conn,
             bool keepIdentityColumnValue,
             IEnumerable<T> dataToInsert,
             List<string> propertiesToIgnore,
             Dictionary<string, string> renameFields,
-            int batchSize = 5000)
+            int batchSize = 5000, 
+            bool noBatch = false)
         {
             var targetProperties = GetTargetProperties<T>(propertiesToIgnore, renameFields);
 
             var options = SqlBulkCopyOptions.CheckConstraints | SqlBulkCopyOptions.TableLock;
 
             if (keepIdentityColumnValue)
             {
-                options = options | SqlBulkCopyOptions.KeepIdentity;
+                options |= SqlBulkCopyOptions.KeepIdentity;
             }
 
+            if (noBatch)
+            {
+                BulkCopyWithNoBatching(tableName, conn, dataToInsert, options, targetProperties);
+            }
+            else
+            {
+                BulkCopyWithBatching(tableName, conn, dataToInsert, batchSize, options, targetProperties);
+            }
+        }
+
+        private void BulkCopyWithNoBatching<T>(string tableName, SqlConnection conn, IEnumerable<T> dataToInsert,
+            SqlBulkCopyOptions options, TargetProperty[] targetProperties)
+        {
+            _sqlBulkCopyUtility.BulkCopy(tableName, conn, options, targetProperties, dataToInsert);
+        }
+
+        private void BulkCopyWithBatching<T>(string tableName, SqlConnection conn, IEnumerable<T> dataToInsert, int batchSize,
+            SqlBulkCopyOptions options, TargetProperty[] targetProperties)
+        {
             var batch = new List<T>(batchSize);
 
             foreach (var item in dataToInsert)
@@ -121,7 +144,7 @@ public void Insert<T>(
                 batch.Clear();
             }
         }
-        
+
         public class SqlBulkCopyUtility: ISqlBulkCopyUtility
         {
             public void BulkCopy<T>(string tableName, SqlConnection conn, SqlBulkCopyOptions options,

src/ivaldez.SqlBulkLoader/BulkLoaderContext.cs

@@ -16,6 +16,7 @@ public class BulkLoaderContext<T>
 
         private readonly List<string> _withoutMembers;
         private int _batchSize;
+        private bool _noBatch;
 
         public BulkLoaderContext(
             IBulkLoader bulkLoader,
@@ -72,6 +73,13 @@ public BulkLoaderContext<T> SetBatchSize(int value)
             return this;
         }
 
+        public BulkLoaderContext<T> NoBatch()
+        {
+            _noBatch = true;
+
+            return this;
+        }
+
         public void Execute()
         {
             _bulkLoader.Insert(
@@ -81,7 +89,8 @@ public void Execute()
                 _dataToInsert,
                 _withoutMembers,
                 _renameFields,
-                _batchSize);
+                _batchSize,
+                _noBatch);
         }
 
         private string GetName(Expression<Func<T, object>> expression)

src/ivaldez.SqlBulkLoader/IBulkLoader.cs

@@ -14,7 +14,8 @@ void Insert<T>(
             SqlConnection conn,
             bool keepIdentityColumnValue,
             IEnumerable<T> dataToInsert,
-            int batchSize = 5000);
+            int batchSize = 5000,
+            bool noBatch = false);
 
         BulkLoaderContext<T> InsertWithOptions<T>(
             string tableName,
@@ -23,13 +24,13 @@ BulkLoaderContext<T> InsertWithOptions<T>(
             IEnumerable<T> dataToInsert,
             int batchSize = 5000);
 
-        void Insert<T>(
-            string tableName,
+        void Insert<T>(string tableName,
             SqlConnection conn,
             bool keepIdentityColumnValue,
             IEnumerable<T> dataToInsert,
             List<string> propertiesToIgnore,
             Dictionary<string, string> renameFields,
-            int batchSize = 5000);
+            int batchSize = 5000,
+            bool noBatch = false);
     }
 }