Add IgnoreCommandTransaction. Fixes #474

Author: bgrainger

docs/content/connection-options.md

@@ -196,6 +196,12 @@ These are the other options that MySqlConnector supports. They are set to sensib
       See the note in the <a href="https://docs.microsoft.com/en-us/dotnet/api/system.data.sqlclient.sqlcommand.commandtimeout">Microsoft documentation</a>
       for more explanation of how this is determined.</td>
   </tr>
+  <tr>
+    <td>IgnoreCommandTransaction, Ignore Command Transaction</td>
+    <td>false</td>
+    <td>If <code>true</code>, the value of <code>MySqlCommand.Transaction</code> is ignored when commands are executed.
+    This matches the Connector/NET behaviour and can make porting code easier. For more information, see <a href="https://github.com/mysql-net/MySqlConnector/issues/474">Issue 474</a>.</td>
+  </tr>
   <tr>
     <td>Keep Alive, Keepalive</td>
     <td>0</td>

docs/content/tutorials/migrating-from-connector-net.md

@@ -74,7 +74,8 @@ object to be created. See [#331](https://github.com/mysql-net/MySqlConnector/iss
 
 Connector/NET allows a command to be executed even when `MySqlCommand.Transaction` references a commited, rolled back, or
 disposed `MySqlTransaction`. MySqlConnector will throw an `InvalidOperationException` if the `MySqlCommand.Transaction`
-property doesn't reference the active transaction. See [#333](https://github.com/mysql-net/MySqlConnector/issues/333) for more details.
+property doesn't reference the active transaction. To disable this strict validation, set <code>IgnoreCommandTransaction=true</code>
+in the connection string. See [Issue 474](https://github.com/mysql-net/MySqlConnector/issues/474) for more details.
 
 ### Exceptions
 
@@ -104,7 +105,7 @@ The following bugs in Connector/NET are fixed by switching to MySqlConnector.
 * [#81650](https://bugs.mysql.com/bug.php?id=81650), [#88962](https://bugs.mysql.com/bug.php?id=88962): `Server` connection string option may now contain multiple, comma separated hosts that will be tried in order until a connection succeeds
 * [#83229](https://bugs.mysql.com/bug.php?id=83329): "Unknown command" exception inserting large blob with UseCompression=True
 * [#84220](https://bugs.mysql.com/bug.php?id=84220): Cannot call a stored procedure with `.` in its name
-* [#84701](https://bugs.mysql.com/bug.php?id=84701): Can't create a paramter using a 64-bit enum with a value greater than int.MaxValue
+* [#84701](https://bugs.mysql.com/bug.php?id=84701): Can't create a parameter using a 64-bit enum with a value greater than int.MaxValue
 * [#85185](https://bugs.mysql.com/bug.php?id=85185): `ConnectionReset=True` does not preserve connection charset
 * [#86263](https://bugs.mysql.com/bug.php?id=86263): Transaction isolation level affects all transactions in session
 * [#87307](https://bugs.mysql.com/bug.php?id=87307): NextResult hangs instead of timing out

src/MySqlConnector/Core/ConnectionSettings.cs

@@ -57,6 +57,7 @@ public ConnectionSettings(MySqlConnectionStringBuilder csb)
 			ConvertZeroDateTime = csb.ConvertZeroDateTime;
 			DefaultCommandTimeout = (int) csb.DefaultCommandTimeout;
 			ForceSynchronous = csb.ForceSynchronous;
+			IgnoreCommandTransaction = csb.IgnoreCommandTransaction;
 			Keepalive = csb.Keepalive;
 			OldGuids = csb.OldGuids;
 			PersistSecurityInfo = csb.PersistSecurityInfo;
@@ -106,6 +107,7 @@ public ConnectionSettings(MySqlConnectionStringBuilder csb)
 		public bool ConvertZeroDateTime { get; }
 		public int DefaultCommandTimeout { get; }
 		public bool ForceSynchronous { get; }
+		public bool IgnoreCommandTransaction { get; }
 		public uint Keepalive { get; }
 		public bool OldGuids { get; }
 		public bool PersistSecurityInfo { get; }

src/MySqlConnector/MySql.Data.MySqlClient/MySqlCommand.cs

@@ -261,8 +261,8 @@ private bool IsValid(out Exception exception)
 				exception = new InvalidOperationException("Connection property must be non-null.");
 			else if (Connection.State != ConnectionState.Open && Connection.State != ConnectionState.Connecting)
 				exception = new InvalidOperationException("Connection must be Open; current state is {0}".FormatInvariant(Connection.State));
-			else if (Transaction != Connection.CurrentTransaction)
-				exception = new InvalidOperationException("The transaction associated with this command is not the connection's active transaction.");
+			else if (!Connection.IgnoreCommandTransaction && Transaction != Connection.CurrentTransaction)
+				exception = new InvalidOperationException("The transaction associated with this command is not the connection's active transaction; see https://github.com/mysql-net/MySqlConnector/issues/474");
 			else if (string.IsNullOrWhiteSpace(CommandText))
 				exception = new InvalidOperationException("CommandText must be specified");
 			return exception == null;

src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnection.cs

@@ -349,6 +349,7 @@ internal async Task<CachedProcedure> GetCachedProcedure(IOBehavior ioBehavior, s
 		internal bool AllowUserVariables => m_connectionSettings.AllowUserVariables;
 		internal bool ConvertZeroDateTime => m_connectionSettings.ConvertZeroDateTime;
 		internal int DefaultCommandTimeout => GetConnectionSettings().DefaultCommandTimeout;
+		internal bool IgnoreCommandTransaction => m_connectionSettings.IgnoreCommandTransaction;
 		internal bool OldGuids => m_connectionSettings.OldGuids;
 		internal bool TreatTinyAsBoolean => m_connectionSettings.TreatTinyAsBoolean;
 		internal IOBehavior AsyncIOBehavior => GetConnectionSettings().ForceSynchronous ? IOBehavior.Synchronous : IOBehavior.Asynchronous;

src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnectionStringBuilder.cs

@@ -171,6 +171,12 @@ public bool ForceSynchronous
 			set => MySqlConnectionStringOption.ForceSynchronous.SetValue(this, value);
 		}
 
+		public bool IgnoreCommandTransaction
+		{
+			get => MySqlConnectionStringOption.IgnoreCommandTransaction.GetValue(this);
+			set => MySqlConnectionStringOption.IgnoreCommandTransaction.SetValue(this, value);
+		}
+
 		public uint Keepalive
 		{
 			get => MySqlConnectionStringOption.Keepalive.GetValue(this);
@@ -290,6 +296,7 @@ internal abstract class MySqlConnectionStringOption
 		public static readonly MySqlConnectionStringOption<bool> ConvertZeroDateTime;
 		public static readonly MySqlConnectionStringOption<uint> DefaultCommandTimeout;
 		public static readonly MySqlConnectionStringOption<bool> ForceSynchronous;
+		public static readonly MySqlConnectionStringOption<bool> IgnoreCommandTransaction;
 		public static readonly MySqlConnectionStringOption<uint> Keepalive;
 		public static readonly MySqlConnectionStringOption<bool> OldGuids;
 		public static readonly MySqlConnectionStringOption<bool> PersistSecurityInfo;
@@ -428,6 +435,10 @@ static MySqlConnectionStringOption()
 				keys: new[] { "ForceSynchronous" },
 				defaultValue: false));
 
+			AddOption(IgnoreCommandTransaction = new MySqlConnectionStringOption<bool>(
+				keys: new[] { "IgnoreCommandTransaction", "Ignore Command Transaction" },
+				defaultValue: false));
+
 			AddOption(Keepalive = new MySqlConnectionStringOption<uint>(
 				keys: new[] { "Keep Alive", "Keepalive" },
 				defaultValue: 0u));

tests/MySqlConnector.Tests/MySqlConnectionStringBuilderTests.cs

@@ -32,6 +32,7 @@ public void Defaults()
 			Assert.Equal(0u, csb.ConnectionIdlePingTime);
 			Assert.Equal(180u, csb.ConnectionIdleTimeout);
 			Assert.False(csb.ForceSynchronous);
+			Assert.False(csb.IgnoreCommandTransaction);
 			Assert.Null(csb.CACertificateFile);
 			Assert.Equal(MySqlLoadBalance.RoundRobin, csb.LoadBalance);
 #endif
@@ -80,6 +81,7 @@ public void ParseConnectionString()
 					"connection idle ping time=60;" +
 					"connectionidletimeout=30;" +
 					"forcesynchronous=true;" +
+					"ignore command transaction=true;" +
 					"ca certificate file=ca.pem;" +
 					"allow public key retrieval = true;" +
 					"server rsa public key file=rsa.pem;" +
@@ -113,6 +115,7 @@ public void ParseConnectionString()
 			Assert.Equal(60u, csb.ConnectionIdlePingTime);
 			Assert.Equal(30u, csb.ConnectionIdleTimeout);
 			Assert.True(csb.ForceSynchronous);
+			Assert.True(csb.IgnoreCommandTransaction);
 			Assert.Equal("ca.pem", csb.CACertificateFile);
 			Assert.True(csb.AllowPublicKeyRetrieval);
 			Assert.Equal("rsa.pem", csb.ServerRsaPublicKeyFile);

tests/SideBySide/CommandTests.cs

@@ -22,6 +22,20 @@ public void CreateCommandSetsConnection()
 			}
 		}
 
+		[Fact]
+		public void CreateCommandDoesNotSetTransaction()
+		{
+			using (var connection = new MySqlConnection(AppConfig.ConnectionString))
+			{
+				connection.Open();
+				using (connection.BeginTransaction())
+				using (var cmd = connection.CreateCommand())
+				{
+					Assert.Null(cmd.Transaction);
+				}
+			}
+		}
+
 		[Fact]
 		public void ExecuteReaderRequiresConnection()
 		{
@@ -87,6 +101,89 @@ public async Task ExecuteNonQueryReturnValue()
 			}
 		}
 
+		[SkippableFact(Baseline = "https://bugs.mysql.com/bug.php?id=88611")]
+		public void CommandTransactionMustBeSet()
+		{
+			using (var connection = new MySqlConnection(AppConfig.ConnectionString))
+			{
+				connection.Open();
+				using (var transaction = connection.BeginTransaction())
+				using (var command = connection.CreateCommand())
+				{
+					command.CommandText = "SELECT 1;";
+					Assert.Throws<InvalidOperationException>(() => command.ExecuteScalar());
+
+					command.Transaction = transaction;
+					Assert.Equal(1L, command.ExecuteScalar());
+				}
+			}
+		}
+
+		[Fact]
+		public void IgnoreCommandTransactionIgnoresNull()
+		{
+			using (var connection = new MySqlConnection(GetIgnoreCommandTransactionConnectionString()))
+			{
+				connection.Open();
+				using (connection.BeginTransaction())
+				using (var command = connection.CreateCommand())
+				{
+					command.CommandText = "SELECT 1;";
+					Assert.Equal(1L, command.ExecuteScalar());
+				}
+			}
+		}
+
+		[Fact]
+		public void IgnoreCommandTransactionIgnoresDisposedTransaction()
+		{
+			using (var connection = new MySqlConnection(GetIgnoreCommandTransactionConnectionString()))
+			{
+				connection.Open();
+
+				var transaction = connection.BeginTransaction();
+				transaction.Commit();
+				transaction.Dispose();
+
+				using (var command = connection.CreateCommand())
+				{
+					command.CommandText = "SELECT 1;";
+					command.Transaction = transaction;
+					Assert.Equal(1L, command.ExecuteScalar());
+				}
+			}
+		}
+
+		[Fact]
+		public void IgnoreCommandTransactionIgnoresDifferentTransaction()
+		{
+			using (var connection1 = new MySqlConnection(AppConfig.ConnectionString))
+			using (var connection2 = new MySqlConnection(GetIgnoreCommandTransactionConnectionString()))
+			{
+				connection1.Open();
+				connection2.Open();
+				using (var transaction1 = connection1.BeginTransaction())
+				using (var command2 = connection2.CreateCommand())
+				{
+					command2.Transaction = transaction1;
+					command2.CommandText = "SELECT 1;";
+					Assert.Equal(1L, command2.ExecuteScalar());
+				}
+			}
+		}
+
+		private static string GetIgnoreCommandTransactionConnectionString()
+		{
+#if BASELINE
+			return AppConfig.ConnectionString;
+#else
+			return new MySqlConnectionStringBuilder(AppConfig.ConnectionString)
+			{
+				IgnoreCommandTransaction = true
+			}.ConnectionString;
+#endif
+		}
+
 		readonly DatabaseFixture m_database;
 	}
 }

tests/SideBySide/Transaction.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Dapper;
 using MySql.Data.MySqlClient;
@@ -91,16 +91,6 @@ public void NoCommit()
 			Assert.Equal(new int[0], results);
 		}
 
-		[Fact]
-		public void CommandTransactionIsNull()
-		{
-			using (var trans = m_connection.BeginTransaction())
-			using (var cmd = m_connection.CreateCommand())
-			{
-				Assert.Null(cmd.Transaction);
-			}
-		}
-
 		readonly TransactionFixture m_database;
 		readonly MySqlConnection m_connection;
 	}