Add a generic batcher for insert/update/delete statements, usable with PostgreSQL and others

src/NHibernate.Test/Ado/BatcherFixture.cs

@@ -59,6 +59,7 @@ private void FillDb()
 			{
 				s.Save(new VerySimple {Id = 1, Name = "Fabio", Weight = 119.5});
 				s.Save(new VerySimple {Id = 2, Name = "Fiamma", Weight = 9.8});
+				s.Save(new VerySimple {Id = 3, Name = "Roberto", Weight = 98.8 });
 				tx.Commit();
 			}
 		}
@@ -74,11 +75,14 @@ public void OneRoundTripUpdate()
 			{
 				var vs1 = s.Get<VerySimple>(1);
 				var vs2 = s.Get<VerySimple>(2);
+				var vs3 = s.Get<VerySimple>(3);
 				vs1.Weight -= 10;
 				vs2.Weight -= 1;
+				vs3.Weight -= 5;
 				Sfi.Statistics.Clear();
 				s.Update(vs1);
 				s.Update(vs2);
+				s.Update(vs3);
 				tx.Commit();
 			}
 
@@ -154,9 +158,11 @@ public void OneRoundTripDelete()
 			{
 				var vs1 = s.Get<VerySimple>(1);
 				var vs2 = s.Get<VerySimple>(2);
+				var vs3 = s.Get<VerySimple>(3);
 				Sfi.Statistics.Clear();
 				s.Delete(vs1);
 				s.Delete(vs2);
+				s.Delete(vs3);
 				tx.Commit();
 			}
 

src/NHibernate.Test/Ado/GenericBatchingBatcherFixture.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections;
+using System.Linq;
+using NHibernate.AdoNet;
+using NHibernate.Cfg;
+using NHibernate.Dialect;
+using NUnit.Framework;
+using Environment = NHibernate.Cfg.Environment;
+
+namespace NHibernate.Test.Ado
+{
+	[TestFixture]
+	public class GenericBatchingBatcherFixture : TestCase
+	{
+		protected override string MappingsAssembly => "NHibernate.Test";
+
+		protected override IList Mappings => new[] {"Ado.VerySimple.hbm.xml"};
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.BatchStrategy, typeof(GenericBatchingBatcherFactory).AssemblyQualifiedName);
+			configuration.SetProperty(Environment.GenerateStatistics, "true");
+			configuration.SetProperty(Environment.BatchSize, "1000");
+		}
+
+		protected override bool AppliesTo(Dialect.Dialect dialect)
+		{
+			return !(dialect is FirebirdDialect) &&
+			       !(dialect is Oracle8iDialect) &&
+			       !(dialect is MsSqlCeDialect);
+		}
+
+		[Test]
+		public void MassiveInsertUpdateDeleteTest()
+		{
+			var totalRecords = 1000;
+			BatchInsert(totalRecords);
+			BatchUpdate(totalRecords);
+			BatchDelete(totalRecords);
+
+			DbShoudBeEmpty();
+		}
+
+		[Test]
+		public void BatchSizeTest()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.SetBatchSize(5);
+				for (var i = 0; i < 20; i++)
+				{
+					s.Save(new VerySimple { Id = 1 + i, Name = $"Fabio{i}", Weight = 1.45 + i });
+				}
+				tx.Commit();
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(4, Is.EqualTo(FindAllOccurrences(log, "Batch commands:")));
+			}
+			Cleanup();
+		}
+
+		private void BatchInsert(int totalRecords)
+		{
+			Sfi.Statistics.Clear();
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				for (var i = 0; i < totalRecords; i++)
+				{
+					s.Save(new VerySimple {Id = 1 + i, Name = $"Fabio{i}", Weight = 1.45 + i});
+				}
+				tx.Commit();
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		public void BatchUpdate(int totalRecords)
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = s.Query<VerySimple>().ToList();
+				Assert.That(items.Count, Is.EqualTo(totalRecords));
+
+				foreach (var item in items)
+				{
+					item.Weight += 5;
+					s.Update(item);
+				}
+
+				Sfi.Statistics.Clear();
+				tx.Commit();
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		public void BatchDelete(int totalRecords)
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = s.Query<VerySimple>().ToList();
+				Assert.That(items.Count, Is.EqualTo(totalRecords));
+
+				foreach (var item in items)
+				{
+					s.Delete(item);
+				}
+
+				Sfi.Statistics.Clear();
+				tx.Commit();
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		private void DbShoudBeEmpty()
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = s.Query<VerySimple>().ToList();
+				Assert.That(items.Count, Is.EqualTo(0));
+
+				tx.Commit();
+			}
+		}
+
+		private void Cleanup()
+		{
+			using (var s = Sfi.OpenSession())
+			using (s.BeginTransaction())
+			{
+				s.CreateQuery("delete from VerySimple").ExecuteUpdate();
+				s.Transaction.Commit();
+			}
+		}
+
+		private int FindAllOccurrences(string source, string substring)
+		{
+			if (source == null)
+			{
+				return 0;
+			}
+			int n = 0, count = 0;
+			while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
+			{
+				n += substring.Length;
+				++count;
+			}
+			return count;
+		}
+	}
+}

src/NHibernate.Test/Async/Ado/BatcherFixture.cs

@@ -71,6 +71,7 @@ public async Task OneRoundTripInsertsAsync()
 			{
 				await (s.SaveAsync(new VerySimple {Id = 1, Name = "Fabio", Weight = 119.5}, cancellationToken));
 				await (s.SaveAsync(new VerySimple {Id = 2, Name = "Fiamma", Weight = 9.8}, cancellationToken));
+				await (s.SaveAsync(new VerySimple {Id = 3, Name = "Roberto", Weight = 98.8 }, cancellationToken));
 				await (tx.CommitAsync(cancellationToken));
 			}
 		}
@@ -86,11 +87,14 @@ public async Task OneRoundTripUpdateAsync()
 			{
 				var vs1 = await (s.GetAsync<VerySimple>(1));
 				var vs2 = await (s.GetAsync<VerySimple>(2));
+				var vs3 = await (s.GetAsync<VerySimple>(3));
 				vs1.Weight -= 10;
 				vs2.Weight -= 1;
+				vs3.Weight -= 5;
 				Sfi.Statistics.Clear();
 				await (s.UpdateAsync(vs1));
 				await (s.UpdateAsync(vs2));
+				await (s.UpdateAsync(vs3));
 				await (tx.CommitAsync());
 			}
 
@@ -166,9 +170,11 @@ public async Task OneRoundTripDeleteAsync()
 			{
 				var vs1 = await (s.GetAsync<VerySimple>(1));
 				var vs2 = await (s.GetAsync<VerySimple>(2));
+				var vs3 = await (s.GetAsync<VerySimple>(3));
 				Sfi.Statistics.Clear();
 				await (s.DeleteAsync(vs1));
 				await (s.DeleteAsync(vs2));
+				await (s.DeleteAsync(vs3));
 				await (tx.CommitAsync());
 			}
 

src/NHibernate.Test/Async/Ado/GenericBatchingBatcherFixture.cs

@@ -0,0 +1,168 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Collections;
+using System.Linq;
+using NHibernate.AdoNet;
+using NHibernate.Cfg;
+using NHibernate.Dialect;
+using NUnit.Framework;
+using Environment = NHibernate.Cfg.Environment;
+using NHibernate.Linq;
+
+namespace NHibernate.Test.Ado
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	[TestFixture]
+	public class GenericBatchingBatcherFixtureAsync : TestCase
+	{
+		protected override string MappingsAssembly => "NHibernate.Test";
+
+		protected override IList Mappings => new[] {"Ado.VerySimple.hbm.xml"};
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.BatchStrategy, typeof(GenericBatchingBatcherFactory).AssemblyQualifiedName);
+			configuration.SetProperty(Environment.GenerateStatistics, "true");
+			configuration.SetProperty(Environment.BatchSize, "1000");
+		}
+
+		protected override bool AppliesTo(Dialect.Dialect dialect)
+		{
+			return !(dialect is FirebirdDialect) &&
+			       !(dialect is Oracle8iDialect) &&
+			       !(dialect is MsSqlCeDialect);
+		}
+
+		[Test]
+		public async Task MassiveInsertUpdateDeleteTestAsync()
+		{
+			var totalRecords = 1000;
+			await (BatchInsertAsync(totalRecords));
+			await (BatchUpdateAsync(totalRecords));
+			await (BatchDeleteAsync(totalRecords));
+
+			await (DbShoudBeEmptyAsync());
+		}
+
+		[Test]
+		public async Task BatchSizeTestAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.SetBatchSize(5);
+				for (var i = 0; i < 20; i++)
+				{
+					await (s.SaveAsync(new VerySimple { Id = 1 + i, Name = $"Fabio{i}", Weight = 1.45 + i }));
+				}
+				await (tx.CommitAsync());
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(4, Is.EqualTo(FindAllOccurrences(log, "Batch commands:")));
+			}
+			await (CleanupAsync());
+		}
+
+		private async Task BatchInsertAsync(int totalRecords, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			Sfi.Statistics.Clear();
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				for (var i = 0; i < totalRecords; i++)
+				{
+					await (s.SaveAsync(new VerySimple {Id = 1 + i, Name = $"Fabio{i}", Weight = 1.45 + i}, cancellationToken));
+				}
+				await (tx.CommitAsync(cancellationToken));
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		public async Task BatchUpdateAsync(int totalRecords, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = await (s.Query<VerySimple>().ToListAsync(cancellationToken));
+				Assert.That(items.Count, Is.EqualTo(totalRecords));
+
+				foreach (var item in items)
+				{
+					item.Weight += 5;
+					await (s.UpdateAsync(item, cancellationToken));
+				}
+
+				Sfi.Statistics.Clear();
+				await (tx.CommitAsync(cancellationToken));
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		public async Task BatchDeleteAsync(int totalRecords, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = await (s.Query<VerySimple>().ToListAsync(cancellationToken));
+				Assert.That(items.Count, Is.EqualTo(totalRecords));
+
+				foreach (var item in items)
+				{
+					await (s.DeleteAsync(item, cancellationToken));
+				}
+
+				Sfi.Statistics.Clear();
+				await (tx.CommitAsync(cancellationToken));
+			}
+			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+		}
+
+		private async Task DbShoudBeEmptyAsync(CancellationToken cancellationToken = default(CancellationToken))
+		{
+			using (var s = Sfi.OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var items = await (s.Query<VerySimple>().ToListAsync(cancellationToken));
+				Assert.That(items.Count, Is.EqualTo(0));
+
+				await (tx.CommitAsync(cancellationToken));
+			}
+		}
+
+		private async Task CleanupAsync(CancellationToken cancellationToken = default(CancellationToken))
+		{
+			using (var s = Sfi.OpenSession())
+			using (s.BeginTransaction())
+			{
+				await (s.CreateQuery("delete from VerySimple").ExecuteUpdateAsync(cancellationToken));
+				await (s.Transaction.CommitAsync(cancellationToken));
+			}
+		}
+
+		private int FindAllOccurrences(string source, string substring)
+		{
+			if (source == null)
+			{
+				return 0;
+			}
+			int n = 0, count = 0;
+			while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
+			{
+				n += substring.Length;
+				++count;
+			}
+			return count;
+		}
+	}
+}