Use interface default implementations

gliljas · gliljas · commit 904bbee68c63 · 2024-08-07T20:53:35.000+02:00
diff --git a/src/NHibernate.Test/Ado/BatcherFixture.cs b/src/NHibernate.Test/Ado/BatcherFixture.cs
@@ -168,7 +168,7 @@ public void BatchedoutputShouldBeFormatted()
 			{
 				FillDb();
 				var log = sqlLog.GetWholeLog();
-				Assert.IsTrue(log.Contains("INSERT \n    INTO"));
+				Assert.That(log, Does.Contain("INSERT \n    INTO").IgnoreCase);
 			}
 
 			Cleanup();
@@ -239,7 +239,7 @@ public void AbstractBatcherLog()
 					foreach (var loggingEvent in sl.Appender.GetEvents())
 					{
 						string message = loggingEvent.RenderedMessage;
-						if(message.ToLowerInvariant().Contains("insert"))
+						if(message.Contains("insert"))
 						{
 							Assert.That(message, Does.Contain("batch").IgnoreCase);
 						}
diff --git a/src/NHibernate/AdoNet/ConnectionManager.cs b/src/NHibernate/AdoNet/ConnectionManager.cs
@@ -524,15 +524,15 @@ public void EnlistInTransaction(DbBatch batch)
 			if (batch == null)
 				throw new ArgumentNullException(nameof(batch));
 
-			if (_transaction is ITransactionWithBatchSupport transactionWithBatch)
+			if (_transaction != null)
 			{
-				transactionWithBatch.Enlist(batch);
+				_transaction.Enlist(batch);
 				return;
 			}
 
 			if (batch.Transaction != null)
 			{
-				_log.Warn("set a nonnull DbCommand.Transaction to null because the Session had no Transaction");
+				_log.Warn("set a nonnull DbBatch.Transaction to null because the Session had no Transaction");
 				batch.Transaction = null;
 			}
 		}
diff --git a/src/NHibernate/AdoNet/DbBatchBatcher.cs b/src/NHibernate/AdoNet/DbBatchBatcher.cs
@@ -1,4 +1,4 @@
-﻿#if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
 using System;
 using System.Data.Common;
 using System.Linq;
@@ -26,7 +26,7 @@ public DbBatchBatcher(ConnectionManager connectionManager, IInterceptor intercep
 		{
 			_batchSize = Factory.Settings.AdoBatchSize;
 			_defaultTimeout = Driver.GetCommandTimeout();
-			
+
 			_currentBatch = CreateConfiguredBatch();
 			//we always create this, because we need to deal with a scenario in which
 			//the user change the logging configuration at runtime. Trying to put this
@@ -152,7 +152,7 @@ protected override void DoExecuteBatch(DbCommand ps)
 				{
 					throw ADOExceptionHelper.Convert(Factory.SQLExceptionConverter, e, "could not execute batch command.");
 				}
-				
+
 				Expectations.VerifyOutcomeBatched(_totalExpectedRowsAffected, rowsAffected, ps);
 			}
 			finally
@@ -168,8 +168,7 @@ protected override async Task DoExecuteBatchAsync(DbCommand ps, CancellationToke
 			{
 				Log.Debug("Executing batch");
 				await (CheckReadersAsync(cancellationToken)).ConfigureAwait(false);
-				//await (PrepareAsync(_currentBatch, cancellationToken)).ConfigureAwait(false);
-				Prepare(_currentBatch);
+				await (PrepareAsync(_currentBatch, cancellationToken)).ConfigureAwait(false);
 				if (Factory.Settings.SqlStatementLogger.IsDebugEnabled)
 				{
 					Factory.Settings.SqlStatementLogger.LogBatchCommand(_currentBatchCommandsLog.ToString());
@@ -194,7 +193,7 @@ protected override async Task DoExecuteBatchAsync(DbCommand ps, CancellationToke
 
 		private DbBatch CreateConfiguredBatch()
 		{
-			var result = ((IDriverWithBatchSupport) Driver).CreateBatch();
+			var result = Driver.CreateBatch();
 			if (_defaultTimeout > 0)
 			{
 				try
@@ -218,7 +217,7 @@ private void ClearCurrentBatch()
 			_currentBatch.Dispose();
 			_totalExpectedRowsAffected = 0;
 			_currentBatch = CreateConfiguredBatch();
-			
+
 			if (Factory.Settings.SqlStatementLogger.IsDebugEnabled)
 			{
 				_currentBatchCommandsLog = new StringBuilder().AppendLine("Batch commands:");
@@ -285,7 +284,44 @@ protected void Prepare(DbBatch batch)
 				}
 
 				_connectionManager.EnlistInTransaction(batch);
-				(Driver as IDriverWithBatchSupport).PrepareBatch(batch);
+				Driver.PrepareBatch(batch);
+			}
+			catch (InvalidOperationException ioe)
+			{
+				throw new ADOException("While preparing " + string.Join(Environment.NewLine, batch.BatchCommands.Select(x => x.CommandText)) + " an error occurred", ioe);
+			}
+		}
+
+		/// <summary>
+		/// Prepares the <see cref="DbBatch"/> for execution in the database.
+		/// </summary>
+		/// <remarks>
+		/// This takes care of hooking the <see cref="DbBatch"/> up to an <see cref="DbConnection"/>
+		/// and <see cref="DbTransaction"/> if one exists.  It will call <c>Prepare</c> if the Driver
+		/// supports preparing batches.
+		/// </remarks>
+		protected async Task PrepareAsync(DbBatch batch, CancellationToken cancellationToken)
+		{
+			try
+			{
+				var sessionConnection = await _connectionManager.GetConnectionAsync(cancellationToken).ConfigureAwait(false);
+
+				if (batch.Connection != null)
+				{
+					// make sure the commands connection is the same as the Sessions connection
+					// these can be different when the session is disconnected and then reconnected
+					if (batch.Connection != sessionConnection)
+					{
+						batch.Connection = sessionConnection;
+					}
+				}
+				else
+				{
+					batch.Connection = sessionConnection;
+				}
+
+				_connectionManager.EnlistInTransaction(batch);
+				Driver.PrepareBatch(batch);
 			}
 			catch (InvalidOperationException ioe)
 			{
diff --git a/src/NHibernate/Driver/DbProviderFactoryDriveConnectionCommandProvider.cs b/src/NHibernate/Driver/DbProviderFactoryDriveConnectionCommandProvider.cs
@@ -4,9 +4,6 @@
 namespace NHibernate.Driver
 {
 	public class DbProviderFactoryDriveConnectionCommandProvider : IDriveConnectionCommandProvider
-#if NET6_0_OR_GREATER
-		, IDriveConnectionCommandProviderWithBatchSupport
-#endif
 	{
 		private readonly DbProviderFactory dbProviderFactory;
 
@@ -29,10 +26,7 @@ public DbCommand CreateCommand()
 			return dbProviderFactory.CreateCommand();
 		}
 #if NET6_0_OR_GREATER
-		public DbBatch CreateBatch()
-		{
-			return dbProviderFactory.CreateBatch();
-		}
+		public DbBatch CreateBatch() => dbProviderFactory.CreateBatch();
 
 		public bool CanCreateBatch => dbProviderFactory.CanCreateBatch && dbProviderFactory.CreateCommand() is ICloneable;
 #endif
diff --git a/src/NHibernate/Driver/DriverBase.cs b/src/NHibernate/Driver/DriverBase.cs
@@ -15,9 +15,6 @@ namespace NHibernate.Driver
 	/// Base class for the implementation of IDriver
 	/// </summary>
 	public abstract class DriverBase : IDriver, ISqlParameterFormatter
-#if NET6_0_OR_GREATER
-		, IDriverWithBatchSupport
-#endif
 	{
 		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(DriverBase));
 
diff --git a/src/NHibernate/Driver/IDriveConnectionCommandProvider.cs b/src/NHibernate/Driver/IDriveConnectionCommandProvider.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Data.Common;
 
 namespace NHibernate.Driver
@@ -6,5 +7,9 @@ public interface IDriveConnectionCommandProvider
 	{
 		DbConnection CreateConnection();
 		DbCommand CreateCommand();
+#if NET6_0_OR_GREATER
+		DbBatch CreateBatch() => throw new NotImplementedException();
+		bool CanCreateBatch => false;
+#endif
 	}
-}
+}
diff --git a/src/NHibernate/Driver/IDriveConnectionCommandProviderWithBatchSupport.cs b/src/NHibernate/Driver/IDriveConnectionCommandProviderWithBatchSupport.cs
diff --git a/src/NHibernate/Driver/IDriver.cs b/src/NHibernate/Driver/IDriver.cs
@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
-using System.Linq;
-using System.Windows.Input;
 using NHibernate.Engine;
 using NHibernate.SqlCommand;
 using NHibernate.SqlTypes;
@@ -165,5 +163,13 @@ public interface IDriver
 		/// The minimal date supplied as a <see cref="DateTime" /> supported by this driver.
 		/// </summary>
 		DateTime MinDate { get; }
+
+#if NET6_0_OR_GREATER
+		DbBatch CreateBatch() => throw new NotImplementedException();
+		bool CanCreateBatch => false;
+
+		void AdjustBatch(DbBatch dbBatch) => throw new NotImplementedException();
+		void PrepareBatch(DbBatch dbBatch) => throw new NotImplementedException();
+#endif
 	}
 }
diff --git a/src/NHibernate/Driver/IDriverWithBatchSupport.cs b/src/NHibernate/Driver/IDriverWithBatchSupport.cs
diff --git a/src/NHibernate/Driver/ReflectionBasedDriver.cs b/src/NHibernate/Driver/ReflectionBasedDriver.cs
@@ -75,26 +75,9 @@ public override DbCommand CreateCommand()
 		}
 
 #if NET6_0_OR_GREATER
-		public override DbBatch CreateBatch()
-		{
-			if (connectionCommandProvider is IDriveConnectionCommandProviderWithBatchSupport driveConnectionCommandProviderWithBatch)
-			{
-				return driveConnectionCommandProviderWithBatch.CreateBatch();
-			}
-			throw new NotSupportedException();
-		}
+		public override DbBatch CreateBatch() => connectionCommandProvider.CreateBatch();
 
-		public override bool CanCreateBatch
-		{
-			get
-			{
-				if (connectionCommandProvider is IDriveConnectionCommandProviderWithBatchSupport driveConnectionCommandProviderWithBatch)
-				{
-					return driveConnectionCommandProviderWithBatch.CanCreateBatch;
-				}
-				return false;
-			}
-		}
+		public override bool CanCreateBatch => connectionCommandProvider.CanCreateBatch;
 #endif
 	}
 }
diff --git a/src/NHibernate/Driver/ReflectionDriveConnectionCommandProvider.cs b/src/NHibernate/Driver/ReflectionDriveConnectionCommandProvider.cs
@@ -5,9 +5,6 @@
 namespace NHibernate.Driver
 {
 	public class ReflectionDriveConnectionCommandProvider : IDriveConnectionCommandProvider
-#if NET6_0_OR_GREATER
-		, IDriveConnectionCommandProviderWithBatchSupport
-#endif
 	{
 		private readonly System.Type commandType;
 		private readonly System.Type connectionType;
@@ -49,7 +46,6 @@ public DbCommand CreateCommand()
 		#endregion
 
 #if NET6_0_OR_GREATER
-
 		private Lazy<bool> _canCreateBatch;
 
 		public DbBatch CreateBatch()
@@ -63,8 +59,6 @@ public DbBatch CreateBatch()
 		}
 
 		public bool CanCreateBatch => _canCreateBatch.Value;
-
-	
 #endif
 	}
 }
diff --git a/src/NHibernate/ITransaction.cs b/src/NHibernate/ITransaction.cs
@@ -81,21 +81,18 @@ public partial interface ITransaction : IDisposable
 			"RegisterSynchronization(ITransactionCompletionSynchronization)': the TransactionExtensions extension " +
 			"method will call it.")]
 		void RegisterSynchronization(ISynchronization synchronization);
-	}
 
 #if NET6_0_OR_GREATER
-	internal interface ITransactionWithBatchSupport : ITransaction
-	{
 		/// <summary>
 		/// Enlist a <see cref="DbBatch"/> in the current Transaction.
 		/// </summary>
 		/// <param name="batch">The <see cref="DbBatch"/> to enlist.</param>
 		/// <remarks>
 		/// It is okay for this to be a no op implementation.
 		/// </remarks>
-		void Enlist(DbBatch batch);
-	}
+		void Enlist(DbBatch batch) => throw new NotImplementedException();
 #endif
+	}
 
 	// 6.0 TODO: merge into ITransaction
 	public static class TransactionExtensions
diff --git a/src/NHibernate/Transaction/AdoTransaction.cs b/src/NHibernate/Transaction/AdoTransaction.cs
@@ -13,9 +13,6 @@ namespace NHibernate.Transaction
 	/// the <see cref="ITransaction" /> interface.
 	/// </summary>
 	public partial class AdoTransaction : ITransaction
-#if NET6_0_OR_GREATER
-		, ITransactionWithBatchSupport
-#endif
 	{
 		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(AdoTransaction));
 		private ISessionImplementor session;
@@ -112,7 +109,7 @@ public void Enlist(DbBatch batch)
 				{
 					if (batch.Transaction != null)
 					{
-						log.Warn("set a nonnull DbCommand.Transaction to null because the Session had no Transaction");
+						log.Warn("set a nonnull DbBatch.Transaction to null because the Session had no Transaction");
 					}
 				}
 
@@ -127,11 +124,11 @@ public void Enlist(DbBatch batch)
 					// don't need to be confused by that - just a normal part of initialization...
 					if (batch.Transaction != null && batch.Transaction != trans)
 					{
-						log.Warn("The DbCommand had a different Transaction than the Session.  This can occur when " +
+						log.Warn("The DbBatch had a different Transaction than the Session.  This can occur when " +
 								 "Disconnecting and Reconnecting Sessions because the PreparedCommand Cache is Session specific.");
 					}
 				}
-				log.Debug("Enlist Command");
+				log.Debug("Enlist DbBatch");
 
 				// If you try to assign a disposed transaction to a command with MSSQL, it will leave the command's
 				// transaction as null and not throw an error.  With SQLite, for example, it will throw an exception

Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ public void BatchedoutputShouldBeFormatted()`
`168`	`168`	`{`
`169`	`169`	`FillDb();`
`170`	`170`	`var log = sqlLog.GetWholeLog();`
`171`		`- Assert.IsTrue(log.Contains("INSERT \n INTO"));`
	`171`	`+ Assert.That(log, Does.Contain("INSERT \n INTO").IgnoreCase);`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`Cleanup();`
`@@ -239,7 +239,7 @@ public void AbstractBatcherLog()`
`239`	`239`	`foreach (var loggingEvent in sl.Appender.GetEvents())`
`240`	`240`	`{`
`241`	`241`	`string message = loggingEvent.RenderedMessage;`
`242`		`- if(message.ToLowerInvariant().Contains("insert"))`
	`242`	`+ if(message.Contains("insert"))`
`243`	`243`	`{`
`244`	`244`	`Assert.That(message, Does.Contain("batch").IgnoreCase);`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -524,15 +524,15 @@ public void EnlistInTransaction(DbBatch batch)`
`524`	`524`	`if (batch == null)`
`525`	`525`	`throw new ArgumentNullException(nameof(batch));`
`526`	`526`
`527`		`- if (_transaction is ITransactionWithBatchSupport transactionWithBatch)`
	`527`	`+ if (_transaction != null)`
`528`	`528`	`{`
`529`		`- transactionWithBatch.Enlist(batch);`
	`529`	`+ _transaction.Enlist(batch);`
`530`	`530`	`return;`
`531`	`531`	`}`
`532`	`532`
`533`	`533`	`if (batch.Transaction != null)`
`534`	`534`	`{`
`535`		`- _log.Warn("set a nonnull DbCommand.Transaction to null because the Session had no Transaction");`
	`535`	`+ _log.Warn("set a nonnull DbBatch.Transaction to null because the Session had no Transaction");`
`536`	`536`	`batch.Transaction = null;`
`537`	`537`	`}`
`538`	`538`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,6 @@`
`4`	`4`	`namespace NHibernate.Driver`
`5`	`5`	`{`
`6`	`6`	`public class DbProviderFactoryDriveConnectionCommandProvider : IDriveConnectionCommandProvider`
`7`		`-#if NET6_0_OR_GREATER`
`8`		`- , IDriveConnectionCommandProviderWithBatchSupport`
`9`		`-#endif`
`10`	`7`	`{`
`11`	`8`	`private readonly DbProviderFactory dbProviderFactory;`
`12`	`9`
`@@ -29,10 +26,7 @@ public DbCommand CreateCommand()`
`29`	`26`	`return dbProviderFactory.CreateCommand();`
`30`	`27`	`}`
`31`	`28`	`#if NET6_0_OR_GREATER`
`32`		`- public DbBatch CreateBatch()`
`33`		`- {`
`34`		`- return dbProviderFactory.CreateBatch();`
`35`		`- }`
	`29`	`+ public DbBatch CreateBatch() => dbProviderFactory.CreateBatch();`
`36`	`30`
`37`	`31`	`public bool CanCreateBatch => dbProviderFactory.CanCreateBatch && dbProviderFactory.CreateCommand() is ICloneable;`
`38`	`32`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,6 @@ namespace NHibernate.Driver`
`15`	`15`	`/// Base class for the implementation of IDriver`
`16`	`16`	`/// </summary>`
`17`	`17`	`public abstract class DriverBase : IDriver, ISqlParameterFormatter`
`18`		`-#if NET6_0_OR_GREATER`
`19`		`- , IDriverWithBatchSupport`
`20`		`-#endif`
`21`	`18`	`{`
`22`	`19`	`private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(DriverBase));`
`23`	`20`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Data.Common;`
`2`	`3`
`3`	`4`	`namespace NHibernate.Driver`
`@@ -6,5 +7,9 @@ public interface IDriveConnectionCommandProvider`
`6`	`7`	`{`
`7`	`8`	`DbConnection CreateConnection();`
`8`	`9`	`DbCommand CreateCommand();`
	`10`	`+#if NET6_0_OR_GREATER`
	`11`	`+ DbBatch CreateBatch() => throw new NotImplementedException();`
	`12`	`+ bool CanCreateBatch => false;`
	`13`	`+#endif`
`9`	`14`	`}`
`10`		`-}`
	`15`	`+}`