Cache prepared commands for the lifetime of the session.

Author: bgrainger

src/MySqlConnector/Core/PreparedStatementCommandExecutor.cs

@@ -15,17 +15,18 @@ namespace MySqlConnector.Core
 {
 	internal sealed class PreparedStatementCommandExecutor : ICommandExecutor
 	{
-		public PreparedStatementCommandExecutor(MySqlCommand command)
+		public PreparedStatementCommandExecutor(MySqlCommand command, PreparedStatements preparedStatements)
 		{
 			m_command = command;
+			m_preparedStatements = preparedStatements;
 		}
 
 		public async Task<DbDataReader> ExecuteReaderAsync(string commandText, MySqlParameterCollection parameterCollection, CommandBehavior behavior, IOBehavior ioBehavior, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			if (Log.IsDebugEnabled())
 				Log.Debug("Session{0} ExecuteBehavior {1} CommandText: {2}", m_command.Connection.Session.Id, ioBehavior, commandText);
-			using (var payload = CreateQueryPayload(m_command.PreparedStatements[0], parameterCollection, m_command.Connection.GuidFormat))
+			using (var payload = CreateQueryPayload(m_preparedStatements.Statements[0], parameterCollection, m_command.Connection.GuidFormat))
 			using (m_command.RegisterCancel(cancellationToken))
 			{
 				m_command.Connection.Session.StartQuerying(m_command);
@@ -105,5 +106,6 @@ private PayloadData CreateQueryPayload(PreparedStatement preparedStatement, MySq
 		static IMySqlConnectorLogger Log { get; } = MySqlConnectorLogManager.CreateLogger(nameof(PreparedStatementCommandExecutor));
 
 		readonly MySqlCommand m_command;
+		readonly PreparedStatements m_preparedStatements;
 	}
 }

src/MySqlConnector/Core/ServerSession.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Buffers.Text;
+using System.Collections.Generic;
 using System.Data;
 using System.Diagnostics;
 using System.Globalization;
@@ -126,6 +127,23 @@ public void AbortCancel(MySqlCommand command)
 			}
 		}
 
+		public void AddPreparedStatement(string commandText, PreparedStatements preparedStatements)
+		{
+			if (m_preparedStatements == null)
+				m_preparedStatements = new Dictionary<string, PreparedStatements>();
+			m_preparedStatements.Add(commandText, preparedStatements);
+		}
+
+		public PreparedStatements TryGetPreparedStatement(string commandText)
+		{
+			if (m_preparedStatements != null)
+			{
+				if (m_preparedStatements.TryGetValue(commandText, out var statement))
+					return statement;
+			}
+			return null;
+		}
+
 		public void StartQuerying(MySqlCommand command)
 		{
 			lock (m_lock)
@@ -218,6 +236,8 @@ public async Task DisposeAsync(IOBehavior ioBehavior, CancellationToken cancella
 				}
 			}
 
+			ClearPreparedStatements();
+
 			ShutdownSocket();
 			lock (m_lock)
 				m_state = State.Closed;
@@ -367,6 +387,9 @@ public async Task<bool> TryResetConnectionAsync(ConnectionSettings cs, IOBehavio
 
 			try
 			{
+				// clear all prepared statements; resetting the connection will clear them on the server
+				ClearPreparedStatements();
+
 				if (DatabaseOverride == null && ServerVersion.Version.CompareTo(ServerVersions.SupportsResetConnection) >= 0)
 				{
 					m_logArguments[1] = ServerVersion.OriginalString;
@@ -1322,6 +1345,16 @@ private Exception CreateExceptionForErrorPayload(PayloadData payload)
 			return exception;
 		}
 
+		private void ClearPreparedStatements()
+		{
+			if (m_preparedStatements != null)
+			{
+				foreach (var pair in m_preparedStatements)
+					pair.Value.Dispose();
+				m_preparedStatements.Clear();
+			}
+		}
+
 		private enum State
 		{
 			// The session has been created; no connection has been made.
@@ -1372,5 +1405,6 @@ private enum State
 		bool m_isSecureConnection;
 		bool m_supportsConnectionAttributes;
 		bool m_supportsDeprecateEof;
+		Dictionary<string, PreparedStatements> m_preparedStatements;
 	}
 }

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

@@ -85,6 +85,10 @@ private async Task PrepareAsync(IOBehavior ioBehavior, CancellationToken cancell
 			if (CommandType != CommandType.Text)
 				throw new NotSupportedException("Only CommandType.Text is currently supported by MySqlCommand.Prepare");
 
+			// don't prepare the same SQL twice
+			if (m_connection.Session.TryGetPreparedStatement(CommandText) != null)
+				return;
+
 			var statementPreparer = new StatementPreparer(CommandText, Parameters, CreateStatementPreparerOptions());
 			var parsedStatements = statementPreparer.SplitStatements();
 
@@ -142,8 +146,7 @@ private async Task PrepareAsync(IOBehavior ioBehavior, CancellationToken cancell
 				preparedStatements.Add(new PreparedStatement(response.StatementId, statement, columns, parameters));
 			}
 
-			m_parsedStatements = parsedStatements;
-			m_statements = preparedStatements;
+			m_connection.Session.AddPreparedStatement(CommandText, new PreparedStatements(preparedStatements, parsedStatements));
 		}
 
 		public override string CommandText
@@ -154,11 +157,10 @@ public override string CommandText
 				if (m_connection?.HasActiveReader ?? false)
 					throw new InvalidOperationException("Cannot set MySqlCommand.CommandText when there is an open DataReader for this command; it must be closed first.");
 				m_commandText = value;
-				ClearPreparedStatements();
 			}
 		}
 
-		public bool IsPrepared => m_statements != null;
+		public bool IsPrepared => TryGetPreparedStatement() != null;
 
 		public new MySqlTransaction Transaction { get; set; }
 
@@ -170,7 +172,6 @@ public override string CommandText
 				if (m_connection?.HasActiveReader ?? false)
 					throw new InvalidOperationException("Cannot set MySqlCommand.Connection when there is an open DataReader for this command; it must be closed first.");
 				m_connection = value;
-				ClearPreparedStatements();
 			}
 		}
 
@@ -188,7 +189,6 @@ public override CommandType CommandType
 				if (value != CommandType.Text && value != CommandType.StoredProcedure)
 					throw new ArgumentException("CommandType must be Text or StoredProcedure.", nameof(value));
 				m_commandType = value;
-				ClearPreparedStatements();
 			}
 		}
 
@@ -277,8 +277,9 @@ internal Task<DbDataReader> ExecuteReaderAsync(CommandBehavior behavior, IOBehav
 			if (!IsValid(out var exception))
 				return Utility.TaskFromException<DbDataReader>(exception);
 
-			if (m_statements != null)
-				m_commandExecutor = new PreparedStatementCommandExecutor(this);
+			var preparedStatements = TryGetPreparedStatement();
+			if (preparedStatements != null)
+				m_commandExecutor = new PreparedStatementCommandExecutor(this, preparedStatements);
 			else if (m_commandType == CommandType.Text)
 				m_commandExecutor = new TextCommandExecutor(this);
 			else if (m_commandType == CommandType.StoredProcedure)
@@ -292,10 +293,7 @@ protected override void Dispose(bool disposing)
 			try
 			{
 				if (disposing)
-				{
 					m_parameterCollection = null;
-					ClearPreparedStatements();
-				}
 			}
 			finally
 			{
@@ -324,8 +322,6 @@ internal IDisposable RegisterCancel(CancellationToken token)
 
 		internal int CancelAttemptCount { get; set; }
 
-		internal IReadOnlyList<PreparedStatement> PreparedStatements => m_statements;
-
 		/// <summary>
 		/// Causes the effective command timeout to be reset back to the value specified by <see cref="CommandTimeout"/>.
 		/// </summary>
@@ -400,12 +396,7 @@ private bool IsValid(out Exception exception)
 			return exception == null;
 		}
 
-		private void ClearPreparedStatements()
-		{
-			m_parsedStatements?.Dispose();
-			m_parsedStatements = null;
-			m_statements = null;
-		}
+		private PreparedStatements TryGetPreparedStatement() => CommandType == CommandType.Text && !string.IsNullOrWhiteSpace(CommandText) ? m_connection.Session.TryGetPreparedStatement(CommandText) : null;
 
 		internal void ReaderClosed() => (m_commandExecutor as StoredProcedureCommandExecutor)?.SetParams();
 
@@ -414,8 +405,6 @@ private void ClearPreparedStatements()
 		MySqlConnection m_connection;
 		string m_commandText;
 		MySqlParameterCollection m_parameterCollection;
-		ParsedStatements m_parsedStatements;
-		IReadOnlyList<PreparedStatement> m_statements;
 		int? m_commandTimeout;
 		CommandType m_commandType;
 		ICommandExecutor m_commandExecutor;

src/MySqlConnector/PreparedStatements.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace MySqlConnector.Core
+{
+	internal sealed class PreparedStatements : IDisposable
+	{
+		public IReadOnlyList<PreparedStatement> Statements { get; }
+
+		public PreparedStatements(IReadOnlyList<PreparedStatement> preparedStatements, ParsedStatements parsedStatements)
+		{
+			Statements = preparedStatements;
+			m_parsedStatements = parsedStatements;
+		}
+
+		public void Dispose()
+		{
+			m_parsedStatements?.Dispose();
+			m_parsedStatements = null;
+		}
+
+		ParsedStatements m_parsedStatements;
+	}
+}

tests/SideBySide/PreparedCommandTests.cs

@@ -131,6 +131,41 @@ public void InsertAndQuery(bool isPrepared, string dataType, object dataValue)
 			}
 		}
 
+		[Fact]
+		public void PrepareMultipleTimes()
+		{
+			using (var connection = CreatePrepareConnection())
+			{
+				using (var cmd = new MySqlCommand("SELECT 'test';", connection))
+				{
+					Assert.False(cmd.IsPrepared);
+					cmd.Prepare();
+					Assert.True(cmd.IsPrepared);
+					cmd.Prepare();
+					Assert.Equal("test", cmd.ExecuteScalar());
+				}
+			}
+		}
+
+		[SkippableFact(Baseline = "Connector/NET doesn't cache prepared commands")]
+		public void PreparedCommandIsCached()
+		{
+			using (var connection = CreatePrepareConnection())
+			{
+				using (var cmd = new MySqlCommand("SELECT 'test';", connection))
+				{
+					cmd.Prepare();
+					Assert.Equal("test", cmd.ExecuteScalar());
+				}
+
+				using (var cmd = new MySqlCommand("SELECT 'test';", connection))
+				{
+					Assert.True(cmd.IsPrepared);
+					Assert.Equal("test", cmd.ExecuteScalar());
+				}
+			}
+		}
+
 		public static IEnumerable<object[]> GetInsertAndQueryData()
 		{
 			foreach (var isPrepared in new[] { false, true })