Merge prepared-commands into master.

bgrainger · bgrainger · commit aba7c0ab6105 · 2018-08-24T09:31:51.000-07:00
This caches prepared commands client-side for the lifetime of the prepared command on the server.
diff --git a/src/MySqlConnector/Core/PreparedStatementCommandExecutor.cs b/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;
 	}
 }
diff --git a/src/MySqlConnector/Core/ServerSession.cs b/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;
 	}
 }
diff --git a/src/MySqlConnector/MySql.Data.MySqlClient/MySqlCommand.cs b/src/MySqlConnector/MySql.Data.MySqlClient/MySqlCommand.cs
@@ -65,26 +65,56 @@ public MySqlCommand(string commandText, MySqlConnection connection, MySqlTransac
 
 		public new MySqlDataReader ExecuteReader(CommandBehavior commandBehavior) => (MySqlDataReader) base.ExecuteReader(commandBehavior);
 
-		public override void Prepare() => PrepareAsync(IOBehavior.Synchronous, default).GetAwaiter().GetResult();
+		public override void Prepare()
+		{
+			if (!NeedsPrepare(out var exception))
+			{
+				if (exception != null)
+					throw exception;
+				return;
+			}
+
+			DoPrepareAsync(IOBehavior.Synchronous, default).GetAwaiter().GetResult();
+		}
+
 		public Task PrepareAsync() => PrepareAsync(AsyncIOBehavior, default);
 		public Task PrepareAsync(CancellationToken cancellationToken) => PrepareAsync(AsyncIOBehavior, cancellationToken);
-		
-		private async Task PrepareAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
+
+		private Task PrepareAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
 		{
+			if (!NeedsPrepare(out var exception))
+				return exception != null ? Utility.TaskFromException(exception) : Utility.CompletedTask;
+
+			return DoPrepareAsync(ioBehavior, cancellationToken);
+		}
+
+		private bool NeedsPrepare(out Exception exception)
+		{
+			exception = null;
 			if (Connection == null)
-				throw new InvalidOperationException("Connection property must be non-null.");
-			if (Connection.State != ConnectionState.Open)
-				throw new InvalidOperationException("Connection must be Open; current state is {0}".FormatInvariant(Connection.State));
-			if (string.IsNullOrWhiteSpace(CommandText))
-				throw new InvalidOperationException("CommandText must be specified");
-			if (m_connection?.HasActiveReader ?? false)
-				throw new InvalidOperationException("Cannot call Prepare when there is an open DataReader for this command; it must be closed first.");
-			if (Connection.IgnorePrepare)
-				return;
+				exception = new InvalidOperationException("Connection property must be non-null.");
+			else if (Connection.State != ConnectionState.Open)
+				exception = new InvalidOperationException("Connection must be Open; current state is {0}".FormatInvariant(Connection.State));
+			else if (string.IsNullOrWhiteSpace(CommandText))
+				exception = new InvalidOperationException("CommandText must be specified");
+			else if (Connection?.HasActiveReader ?? false)
+				exception = new InvalidOperationException("Cannot call Prepare when there is an open DataReader for this command; it must be closed first.");
+
+			if (exception != null || Connection.IgnorePrepare)
+				return false;
 
 			if (CommandType != CommandType.Text)
-				throw new NotSupportedException("Only CommandType.Text is currently supported by MySqlCommand.Prepare");
+			{
+				exception = new NotSupportedException("Only CommandType.Text is currently supported by MySqlCommand.Prepare");
+				return false;
+			}
+
+			// don't prepare the same SQL twice
+			return Connection.Session.TryGetPreparedStatement(CommandText) == null;
+		}
 
+		private async Task DoPrepareAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
+		{
 			var statementPreparer = new StatementPreparer(CommandText, Parameters, CreateStatementPreparerOptions());
 			var parsedStatements = statementPreparer.SplitStatements();
 
@@ -142,8 +172,7 @@ private async Task PrepareAsync(IOBehavior ioBehavior, CancellationToken cancell
 				preparedStatements.Add(new PreparedStatement(response.StatementId, statement, columns, parameters));
 			}
 
-			m_parsedStatements = parsedStatements;
-			m_statements = preparedStatements;
+			Connection.Session.AddPreparedStatement(CommandText, new PreparedStatements(preparedStatements, parsedStatements));
 		}
 
 		public override string CommandText
@@ -154,11 +183,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 +198,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 +215,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 +303,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 +319,7 @@ protected override void Dispose(bool disposing)
 			try
 			{
 				if (disposing)
-				{
 					m_parameterCollection = null;
-					ClearPreparedStatements();
-				}
 			}
 			finally
 			{
@@ -324,8 +348,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 +422,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 +431,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;
diff --git a/src/MySqlConnector/PreparedStatements.cs b/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;
+	}
+}
diff --git a/src/MySqlConnector/Utilities/Utility.cs b/src/MySqlConnector/Utilities/Utility.cs
@@ -301,13 +301,31 @@ public static TimeSpan ParseTimeSpan(ReadOnlySpan<byte> value)
 		}
 
 #if NET45
+		public static Task CompletedTask
+		{
+			get
+			{
+				if (s_completedTask == null)
+				{
+					var tcs = new TaskCompletionSource<object>();
+					tcs.SetResult(null);
+					s_completedTask = tcs.Task;
+				}
+				return s_completedTask;
+			}
+		}
+		static Task s_completedTask;
+
+		public static Task TaskFromException(Exception exception) => TaskFromException<object>(exception);
 		public static Task<T> TaskFromException<T>(Exception exception)
 		{
 			var tcs = new TaskCompletionSource<T>();
 			tcs.SetException(exception);
 			return tcs.Task;
 		}
 #else
+		public static Task CompletedTask => Task.CompletedTask;
+		public static Task TaskFromException(Exception exception) => Task.FromException(exception);
 		public static Task<T> TaskFromException<T>(Exception exception) => Task.FromException<T>(exception);
 #endif
 
diff --git a/tests/SideBySide/PreparedCommandTests.cs b/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 })

Original file line number	Diff line number	Diff line change
`@@ -15,17 +15,18 @@ namespace MySqlConnector.Core`
`15`	`15`	`{`
`16`	`16`	`internal sealed class PreparedStatementCommandExecutor : ICommandExecutor`
`17`	`17`	`{`
`18`		`- public PreparedStatementCommandExecutor(MySqlCommand command)`
	`18`	`+ public PreparedStatementCommandExecutor(MySqlCommand command, PreparedStatements preparedStatements)`
`19`	`19`	`{`
`20`	`20`	`m_command = command;`
	`21`	`+ m_preparedStatements = preparedStatements;`
`21`	`22`	`}`
`22`	`23`
`23`	`24`	`public async Task<DbDataReader> ExecuteReaderAsync(string commandText, MySqlParameterCollection parameterCollection, CommandBehavior behavior, IOBehavior ioBehavior, CancellationToken cancellationToken)`
`24`	`25`	`{`
`25`	`26`	`cancellationToken.ThrowIfCancellationRequested();`
`26`	`27`	`if (Log.IsDebugEnabled())`
`27`	`28`	`Log.Debug("Session{0} ExecuteBehavior {1} CommandText: {2}", m_command.Connection.Session.Id, ioBehavior, commandText);`
`28`		`- using (var payload = CreateQueryPayload(m_command.PreparedStatements[0], parameterCollection, m_command.Connection.GuidFormat))`
	`29`	`+ using (var payload = CreateQueryPayload(m_preparedStatements.Statements[0], parameterCollection, m_command.Connection.GuidFormat))`
`29`	`30`	`using (m_command.RegisterCancel(cancellationToken))`
`30`	`31`	`{`
`31`	`32`	`m_command.Connection.Session.StartQuerying(m_command);`
`@@ -105,5 +106,6 @@ private PayloadData CreateQueryPayload(PreparedStatement preparedStatement, MySq`
`105`	`106`	`static IMySqlConnectorLogger Log { get; } = MySqlConnectorLogManager.CreateLogger(nameof(PreparedStatementCommandExecutor));`
`106`	`107`
`107`	`108`	`readonly MySqlCommand m_command;`
	`109`	`+ readonly PreparedStatements m_preparedStatements;`
`108`	`110`	`}`
`109`	`111`	`}`