NH-2176 - fixing db specific issues

Author: fredericDelaporte

src/NHibernate.Test/NHSpecificTest/DtcFailures/DtcFailuresFixture.cs

@@ -184,8 +184,8 @@ public void Will_not_save_when_flush_mode_is_never()
 		[Test]
 		public void When_using_two_sessions_with_explicit_flush()
 		{
-			if (!TestDialect.SupportsConcurrentTransactions)
-				Assert.Ignore(Dialect.GetType().Name + " does not support concurrent transactions.");
+			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
+				Assert.Ignore(Dialect.GetType().Name + " does not support concurrent connections in same transaction.");
 
 			object id1, id2;
 			using (var tx = new TransactionScope())
@@ -222,8 +222,8 @@ public void When_using_two_sessions_with_explicit_flush()
 		[Test]
 		public void When_using_two_sessions()
 		{
-			if (!TestDialect.SupportsConcurrentTransactions)
-				Assert.Ignore(Dialect.GetType().Name + " does not support concurrent transactions.");
+			if (!Dialect.SupportsConcurrentWritingConnectionsInSameTransaction)
+				Assert.Ignore(Dialect.GetType().Name + " does not support concurrent connections in same transaction.");
 
 			object id1, id2;
 			using (var tx = new TransactionScope())

src/NHibernate.Test/NHSpecificTest/NH1632/Fixture.cs

@@ -1,13 +1,10 @@
-using System;
-using System.Data.Common;
+using System.Data.Common;
 using System.Data.Odbc;
 using System.Data.SqlClient;
 using System.Configuration;
-using System.Threading;
 using System.Transactions;
 using NHibernate.Dialect;
 using NHibernate.Driver;
-using NHibernate.Engine;
 using NUnit.Framework;
 
 using Environment = NHibernate.Cfg.Environment;
@@ -98,7 +95,7 @@ public void ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransaction()
 			// here. When having TransactionCompleted event, this event and the second phase
 			// tend to occur before reaching here. But some other NH cases demonstrate that
 			// TransactionCompleted may also occur "too late".
-			((ISessionImplementor) s).TransactionContext?.WaitOne();
+			s.GetSessionImplementation().TransactionContext?.WaitOne();
 
 			// Prior to the patch, an InvalidOperationException exception would occur in the
 			// TransactionCompleted delegate at this point with the message, "Disconnect cannot
@@ -107,8 +104,8 @@ public void ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransaction()
 			// fires *after* the transaction is committed and so it doesn't affect the success
 			// of the transaction.
 			Assert.That(s.IsConnected, Is.False);
-			Assert.That(((ISessionImplementor)s).ConnectionManager.IsConnected, Is.False);
-			Assert.That(((ISessionImplementor)s).IsClosed, Is.True);
+			Assert.That(s.GetSessionImplementation().ConnectionManager.IsConnected, Is.False);
+			Assert.That(s.GetSessionImplementation().IsClosed, Is.True);
 		}
 
 		protected override void OnTearDown()

src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs

@@ -9,28 +9,38 @@ namespace NHibernate.Test.SystemTransactions
 	public class TransactionFixture : TestCase
 	{
 		protected override IList Mappings
+			=> new [] { "WZ.hbm.xml" };
+
+		protected override void OnTearDown()
 		{
-			get { return new string[] { "WZ.hbm.xml" }; }
+			using (var s = sessions.OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.CreateQuery("delete from System.Object").ExecuteUpdate();
+				t.Commit();
+			}
 		}
 
 		[Test]
 		public void CanUseSystemTransactionsToCommit()
 		{
 			object identifier;
-			using(ISession session = sessions.OpenSession())
-			using(TransactionScope tx = new TransactionScope())
+			using(var session = sessions.OpenSession())
+			using(var tx = new TransactionScope())
 			{
-				W s = new W();
+				var s = new W();
 				session.Save(s);
 				identifier = s.Id;
 				tx.Complete();
 			}
 
-			using (ISession session = sessions.OpenSession())
-			using (TransactionScope tx = new TransactionScope())
+			using (var session = sessions.OpenSession())
+			using (var tx = new TransactionScope())
 			{
-				W w = session.Get<W>(identifier);
+				var w = session.Get<W>(identifier);
 				Assert.IsNotNull(w);
+				// Without explicit Flush, this delay the delete to prepare phase, and test flushing from there
+				// while having already acquired a connection due to the Get.
 				session.Delete(w);
 				tx.Complete();
 			}

src/NHibernate.Test/SystemTransactions/TransactionFixture.cs

@@ -33,15 +33,6 @@ public TestDialect(Dialect.Dialect dialect)
 		public virtual bool SupportsOperatorSome { get { return true; } }
 		public virtual bool SupportsLocate { get { return true; } }
 
-		public virtual bool SupportsDistributedTransactions { get { return true; } }
-
-		/// <summary>
-		/// Whether two transactions can be run at the same time.  For example, with SQLite
-		/// the database is locked when one transaction is run, so running a second transaction
-		/// will cause a "database is locked" error message.
-		/// </summary>
-		public virtual bool SupportsConcurrentTransactions { get { return true; } }
-
 		public virtual bool SupportsFullJoin { get { return true; } }
 
         public virtual bool HasBrokenDecimalType { get { return false; } }

src/NHibernate.Test/TestDialect.cs

@@ -21,13 +21,5 @@ public override bool SupportsNullCharactersInUtfStrings
         {
             get { return false; }
         }
-
-        /// <summary>
-        /// Npgsql's DTC code seems to be somewhat broken as of 2.0.11.
-        /// </summary>
-        public override bool SupportsDistributedTransactions
-        {
-            get { return false; }
-        }
 	}
 }

src/NHibernate.Test/TestDialects/PostgreSQL83TestDialect.cs

@@ -27,16 +27,6 @@ public override bool SupportsLocate
 			get { return false; }
 		}
 
-		public override bool SupportsDistributedTransactions
-		{
-			get { return false; }
-		}
-
-		public override bool SupportsConcurrentTransactions
-		{
-			get { return false; }
-		}
-
 		public override bool SupportsFullJoin
 		{
 			get { return false; }

src/NHibernate.Test/TestDialects/SQLiteTestDialect.cs

@@ -69,15 +69,11 @@ public ConnectionManager(
 			ownConnection = suppliedConnection == null;
 		}
 
+		public bool IsInActiveExplicitTransaction
+			=> transaction != null && transaction.IsActive;
+
 		public bool IsInActiveTransaction
-		{
-			get
-			{
-				if (transaction != null && transaction.IsActive)
-					return true;
-				return Factory.TransactionFactory.IsInDistributedActiveTransaction(session);
-			}
-		}
+			=> IsInActiveExplicitTransaction || Factory.TransactionFactory.IsInDistributedActiveTransaction(session);
 
 		public bool IsConnected
 		{
@@ -402,19 +398,31 @@ public IBatcher Batcher
 		}
 
 		/// <summary>
-		/// Tell if according to current ambient transaction, the connection should be explicitly enlisted
-		/// for ensuring it to participate in transaction. Always <see langword="false" /> for supplied
-		/// connection, enlistment is user business in such case.
+		/// Enlist the connection into current ambient transaction if the connection should be explicitly enlisted
+		/// for ensuring it to participate in the ambient transaction. Does nothing for supplied connection,
+		/// enlistment is user business in such case. Does nothing in case an explicit transaction ongoing.
 		/// </summary>
-		public bool RequireExplicitEnlistment
-			=> ownConnection && connection != null &&
-			_connectionAmbientTransaction != System.Transactions.Transaction.Current;
+		public void EnlistIfRequired()
+		{
+			if (!ownConnection || connection == null || IsInActiveExplicitTransaction)
+				return;
+			var tran = System.Transactions.Transaction.Current;
+			if (tran == _connectionAmbientTransaction)
+				return;
+			// Will fail if the connection is already enlisted in another not yet completed transaction.
+			// Probable case: nested transaction scope. Supporting this could be done by releasing the
+			// connection instead of enlisting.
+			session.Connection.EnlistTransaction(tran);
+		}
+
+		private bool RequireConnectionSwapInDtc
+			=> _ownConnection && Factory.Dialect.SupportsConcurrentWritingConnectionsInSameTransaction;
 
 		public IDisposable FlushingFromDtcTransaction
 		{
 			get
 			{
-				if (ownConnection)
+				if (RequireConnectionSwapInDtc)
 				{
 					if (Batcher.HasOpenResources)
 						throw new InvalidOperationException("Batcher still has opened ressources at time of Flush from DTC.");
@@ -431,26 +439,26 @@ public IDisposable FlushingFromDtcTransaction
 
 		private class StopFlushingFromDtcTransaction : IDisposable
 		{
-			private readonly ConnectionManager manager;
+			private readonly ConnectionManager _manager;
 
 			public StopFlushingFromDtcTransaction(ConnectionManager manager)
 			{
-				this.manager = manager;
+				_manager = manager;
 			}
 
 			public void Dispose()
 			{
-				manager.flushingFromDtcTransaction = false;
+				_manager.flushingFromDtcTransaction = false;
 
-				if (manager.ownConnection)
+				if (_manager.RequireConnectionSwapInDtc)
 				{
 					// Release the connection potentially acquired for flushing from DTC.
-					manager.DisconnectOwnConnection();
+					_manager.DisconnectOwnConnection();
 					// Swap back current connection
-					manager.connection = manager._dtcBackupConnection;
-					manager._connectionAmbientTransaction = manager._dtcBackupConnectionAmbientTransaction;
-					manager._dtcBackupConnection = null;
-					manager._dtcBackupConnectionAmbientTransaction = null;
+					_manager.connection = _manager._dtcBackupConnection;
+					_manager._connectionAmbientTransaction = _manager._dtcBackupConnectionAmbientTransaction;
+					_manager._dtcBackupConnection = null;
+					_manager._dtcBackupConnectionAmbientTransaction = null;
 				}
 			}
 		}

src/NHibernate/AdoNet/ConnectionManager.cs

@@ -4,6 +4,7 @@
 using System.Data;
 using System.Data.Common;
 using System.Text;
+using System.Transactions;
 using NHibernate.Dialect.Function;
 using NHibernate.Dialect.Lock;
 using NHibernate.Dialect.Schema;
@@ -1399,6 +1400,16 @@ public IList<SqlString> GetTokens()
 			}
 		}
 
+		/// <summary>
+		/// Does this dialect supports concurrent writing connections?
+		/// </summary>
+		public virtual bool SupportsConcurrentWritingConnections => true;
+
+		/// <summary>
+		/// Does this dialect supports concurrent writing connections in the same transaction?
+		/// </summary>
+		public virtual bool SupportsConcurrentWritingConnectionsInSameTransaction => SupportsConcurrentWritingConnections;
+
 		#endregion
 
 		#region Limit/offset support
@@ -2063,6 +2074,15 @@ public virtual bool SupportsSubSelects
 		/// </summary>
 		public virtual bool SupportsPoolingParameter => true;
 
+		/// <summary>
+		/// Does this dialect support distributed transaction?
+		/// </summary>
+		/// <remarks>
+		/// Distributed transactions usually imply the use of<see cref="TransactionScope"/>, but using
+		/// <c>TransactionScope</c> does not imply the transaction will be distributed.
+		/// </remarks>
+		public virtual bool SupportsDistributedTransactions => true;
+
 		#endregion
 
 		/// <summary>

src/NHibernate/Dialect/Dialect.cs

@@ -129,7 +129,7 @@ public override SqlString GetLimitString(SqlString queryString, SqlString offset
 			return queryString.Insert(insertIndex, limitFragment.ToSqlString());
 		}
 
-		#region Temporaray Table Support
+		#region Temporary Table Support
 
 		public override bool SupportsTemporaryTables
 		{
@@ -424,5 +424,17 @@ private static bool IsUnallowedDecimal(DbType dbType, int precision)
 		{
 			return dbType == DbType.Decimal && precision > MAX_DECIMAL_PRECISION;
 		}
+
+		#region Informational metadata
+
+		/// <summary>
+		/// Does this dialect support distributed transaction?
+		/// </summary>
+		/// <remarks>
+		/// As of v2.5, fails rollback-ing changes when distributed: changes are instead persisted in database.
+		/// </remarks>
+		public override bool SupportsDistributedTransactions => false;
+
+		#endregion
 	}
 }

src/NHibernate/Dialect/FirebirdDialect.cs

@@ -199,6 +199,14 @@ private static int GetAfterSelectInsertPoint(SqlString sql)
 			throw new NotSupportedException("The query should start with 'SELECT' or 'SELECT DISTINCT'");
 		}
 
+		/// <summary>
+		/// Does this dialect supports concurrent writing connections in the same transaction?
+		/// </summary>
+		/// <remarks>
+		/// Likely because this is seen as mandating promotion to distributed, which SQL Ce does not support.
+		/// </remarks>
+		public override bool SupportsConcurrentWritingConnectionsInSameTransaction => false;
+
 		public override long TimestampResolutionInTicks
 		{
 			get
@@ -215,6 +223,15 @@ public override long TimestampResolutionInTicks
 		/// </summary>
 		public override bool SupportsPoolingParameter => false;
 
+		/// <summary>
+		/// Does this dialect support distributed transaction?
+		/// </summary>
+		/// <remarks>
+		/// Fails enlisting a connection into a distributed transaction, fails promoting a transaction
+		/// to distributed when it has already a connection enlisted.
+		/// </remarks>
+		public override bool SupportsDistributedTransactions => false;
+
 		#endregion
 	}
 }

src/NHibernate/Dialect/MsSqlCeDialect.cs

@@ -387,6 +387,15 @@ public override long TimestampResolutionInTicks
 			}
 		}
 
+		/// <summary>
+		/// Does this dialect supports concurrent writing connections in the same transaction?
+		/// </summary>
+		/// <remarks>
+		/// NotSupportedException : Multiple simultaneous connections or connections with different 
+		/// connection strings inside the same transaction are not currently supported.
+		/// </remarks>
+		public override bool SupportsConcurrentWritingConnectionsInSameTransaction => false;
+
 		#region Overridden informational metadata
 
 		public override bool SupportsEmptyInList => false;
@@ -398,6 +407,15 @@ public override long TimestampResolutionInTicks
 
 		public override bool SupportsSubqueryOnMutatingTable => false;
 
+		/// <summary>
+		/// Does this dialect support distributed transaction?
+		/// </summary>
+		/// <remarks>
+		/// Fails enlisting a connection into a distributed transaction, fails promoting a transaction
+		/// to distributed when it has already a connection enlisted.
+		/// </remarks>
+		public override bool SupportsDistributedTransactions => false;
+
 		#endregion
 	}
 }

src/NHibernate/Dialect/MySQLDialect.cs

@@ -265,6 +265,14 @@ public override string CurrentTimestampSelectString
 
 		public override bool SupportsUnboundedLobLocatorMaterialization => false;
 
+		/// <summary>
+		/// Does this dialect support distributed transaction?
+		/// </summary>
+		/// <remarks>
+		/// Fails rollback-ing changes in DTC transaction: changes stay persisted.
+		/// </remarks>
+		public override bool SupportsDistributedTransactions => false;
+
 		#endregion
 	}
 }