Add StatementPreparer.SplitStatements.

This splits a single MySqlCommand.CommandText string into multiple individual SQL statements that can be prepared individually; MySQL Server doesn't support prepared commands that comprise multiple SQL statements.

Signed-off-by: Bradley Grainger <[email protected]>

Author: bgrainger

src/MySqlConnector/Core/ParsedStatement.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace MySqlConnector.Core
+{
+	/// <summary>
+	/// <see cref="ParsedStatement"/> represents an individual SQL statement that's been parsed
+	/// from a string possibly containing multiple semicolon-delimited SQL statements.
+	/// </summary>
+	internal sealed class ParsedStatement
+	{
+		/// <summary>
+		/// The bytes for this statement that will be written on the wire.
+		/// </summary>
+		public ArraySegment<byte> StatementBytes { get; set; }
+
+		/// <summary>
+		/// The names of the parameters (if known) of the parameters in the prepared statement. There
+		/// is one entry in this list for each parameter, which will be <c>null</c> if the name is unknown.
+		/// </summary>
+		public List<string> ParameterNames { get; } = new List<string>();
+
+		/// <summary>
+		/// The indexes of the parameters in the prepared statement. There is one entry in this list for
+		/// each parameter; it will be <c>-1</c> if the parameter is named.
+		/// </summary>
+		public List<int> ParameterIndexes { get; }= new List<int>();
+	}
+}

src/MySqlConnector/Core/ParsedStatements.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using MySqlConnector.Protocol;
+
+namespace MySqlConnector.Core
+{
+	/// <summary>
+	/// <see cref="ParsedStatements"/> wraps a collection of <see cref="ParsedStatement"/> objects.
+	/// It implements <see cref="IDisposable"/> to return the memory backing the statements to a shared pool.
+	/// </summary>
+	internal sealed class ParsedStatements : IDisposable
+	{
+		public IReadOnlyList<ParsedStatement> Statements => m_statements;
+
+		public void Dispose()
+		{
+			m_statements.Clear();
+			m_payloadData.Dispose();
+			m_payloadData = default;
+		}
+
+		internal ParsedStatements(List<ParsedStatement> statements, PayloadData payloadData)
+		{
+			m_statements = statements;
+			m_payloadData = payloadData;
+		}
+
+		readonly List<ParsedStatement> m_statements;
+		PayloadData m_payloadData;
+	}
+}

src/MySqlConnector/Core/SqlParser.cs

@@ -97,7 +97,15 @@ public void Parse(string sql)
 					else
 					{
 						OnPositionalParameter(parameterStartIndex);
-						state = State.Statement;
+						if (ch == ';')
+						{
+							OnStatementEnd(index);
+							state = State.Beginning;
+						}
+						else
+						{
+							state = State.Statement;
+						}
 					}
 				}
 				else if (state == State.AtSign)
@@ -109,7 +117,15 @@ public void Parse(string sql)
 					if (!IsVariableName(ch))
 					{
 						OnNamedParameter(parameterStartIndex, index - parameterStartIndex);
-						state = State.Statement;
+						if (ch == ';')
+						{
+							OnStatementEnd(index);
+							state = State.Beginning;
+						}
+						else
+						{
+							state = State.Statement;
+						}
 					}
 				}
 				else
@@ -147,11 +163,14 @@ public void Parse(string sql)
 					}
 					else if (ch == ';')
 					{
+						if (state != State.Beginning)
+							OnStatementEnd(index);
 						state = State.Beginning;
 					}
 					else if (!IsWhitespace(ch) && state == State.Beginning)
 					{
 						state = State.Statement;
+						OnStatementBegin(index);
 					}
 				}
 			}
@@ -163,6 +182,10 @@ protected virtual void OnBeforeParse(string sql)
 		{
 		}
 
+		protected virtual void OnStatementBegin(int index)
+		{
+		}
+
 		protected virtual void OnPositionalParameter(int index)
 		{
 		}
@@ -171,10 +194,14 @@ protected virtual void OnNamedParameter(int index, int length)
 		{
 		}
 
+		protected virtual void OnStatementEnd(int index)
+		{
+		}
+
 		protected virtual void OnParsed()
 		{
 		}
-		
+
 		private static bool IsWhitespace(char ch) => ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
 
 		private static bool IsVariableName(char ch) => (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '.' || ch == '_' || ch == '$';

src/MySqlConnector/Core/StatementPreparer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Data;
 using MySql.Data.MySqlClient;
 using MySqlConnector.Protocol;
@@ -16,6 +17,18 @@ public StatementPreparer(string commandText, MySqlParameterCollection parameters
 			m_options = options;
 		}
 
+		public ParsedStatements SplitStatements()
+		{
+			var statements = new List<ParsedStatement>();
+			var statementStartEndIndexes = new List<int>();
+			var writer = new ByteBufferWriter(m_commandText.Length + 1);
+			var parser = new PreparedCommandSqlParser(this, statements, statementStartEndIndexes, writer);
+			parser.Parse(m_commandText);
+			for (var i = 0; i < statements.Count; i++)
+				statements[i].StatementBytes = writer.ArraySegment.Slice(statementStartEndIndexes[i * 2], statementStartEndIndexes[i * 2 + 1] - statementStartEndIndexes[i * 2]);
+			return new ParsedStatements(statements, writer.ToPayloadData());
+		}
+
 		public ArraySegment<byte> ParseAndBindParameters()
 		{
 			var writer = new ByteBufferWriter(m_commandText.Length + 1);
@@ -30,6 +43,22 @@ public ArraySegment<byte> ParseAndBindParameters()
 			return writer.ArraySegment;
 		}
 
+		private int GetParameterIndex(string name)
+		{
+			var index = m_parameters.NormalizedIndexOf(name);
+			if (index == -1 && (m_options & StatementPreparerOptions.AllowUserVariables) == 0)
+				throw new MySqlException("Parameter '{0}' must be defined. To use this as a variable, set 'Allow User Variables=true' in the connection string.".FormatInvariant(name));
+			return index;
+		}
+
+		private MySqlParameter GetInputParameter(int index)
+		{
+			var parameter = m_parameters[index];
+			if (parameter.Direction != ParameterDirection.Input && (m_options & StatementPreparerOptions.AllowOutputParameters) == 0)
+				throw new MySqlException("Only ParameterDirection.Input is supported when CommandType is Text (parameter name: {0})".FormatInvariant(parameter.ParameterName));
+			return parameter;
+		}
+
 		private sealed class ParameterSqlParser : SqlParser
 		{
 			public ParameterSqlParser(StatementPreparer preparer, ByteBufferWriter writer)
@@ -38,18 +67,11 @@ public ParameterSqlParser(StatementPreparer preparer, ByteBufferWriter writer)
 				m_writer = writer;
 			}
 
-			protected override void OnBeforeParse(string sql)
-			{
-			}
-
 			protected override void OnNamedParameter(int index, int length)
 			{
-				var parameterName = m_preparer.m_commandText.Substring(index, length);
-				var parameterIndex = m_preparer.m_parameters.NormalizedIndexOf(parameterName);
+				var parameterIndex = m_preparer.GetParameterIndex(m_preparer.m_commandText.Substring(index, length));
 				if (parameterIndex != -1)
 					DoAppendParameter(parameterIndex, index, length);
-				else if ((m_preparer.m_options & StatementPreparerOptions.AllowUserVariables) == 0)
-					throw new MySqlException("Parameter '{0}' must be defined. To use this as a variable, set 'Allow User Variables=true' in the connection string.".FormatInvariant(parameterName));
 			}
 
 			protected override void OnPositionalParameter(int index)
@@ -60,30 +82,83 @@ protected override void OnPositionalParameter(int index)
 
 			private void DoAppendParameter(int parameterIndex, int textIndex, int textLength)
 			{
-				AppendString(m_preparer.m_commandText, m_lastIndex, textIndex - m_lastIndex);
-				var parameter = m_preparer.m_parameters[parameterIndex];
-				if (parameter.Direction != ParameterDirection.Input && (m_preparer.m_options & StatementPreparerOptions.AllowOutputParameters) == 0)
-					throw new MySqlException("Only ParameterDirection.Input is supported when CommandType is Text (parameter name: {0})".FormatInvariant(parameter.ParameterName));
-				m_preparer.m_parameters[parameterIndex].AppendSqlString(m_writer, m_preparer.m_options, parameter.ParameterName);
+				m_writer.Write(m_preparer.m_commandText, m_lastIndex, textIndex - m_lastIndex);
+				var parameter = m_preparer.GetInputParameter(parameterIndex);
+				parameter.AppendSqlString(m_writer, m_preparer.m_options);
 				m_lastIndex = textIndex + textLength;
 			}
 
 			protected override void OnParsed()
 			{
-				AppendString(m_preparer.m_commandText, m_lastIndex, m_preparer.m_commandText.Length - m_lastIndex);
+				m_writer.Write(m_preparer.m_commandText, m_lastIndex, m_preparer.m_commandText.Length - m_lastIndex);
+			}
+
+			readonly StatementPreparer m_preparer;
+			readonly ByteBufferWriter m_writer;
+			int m_currentParameterIndex;
+			int m_lastIndex;
+		}
+
+		private sealed class PreparedCommandSqlParser : SqlParser
+		{
+			public PreparedCommandSqlParser(StatementPreparer preparer, List<ParsedStatement> statements, List<int> statementStartEndIndexes, ByteBufferWriter writer)
+			{
+				m_preparer = preparer;
+				m_statements = statements;
+				m_statementStartEndIndexes = statementStartEndIndexes;
+				m_writer = writer;
+			}
+
+			protected override void OnStatementBegin(int index)
+			{
+				m_statements.Add(new ParsedStatement());
+				m_statementStartEndIndexes.Add(m_writer.Position);
+				m_writer.Write((byte) CommandKind.StatementPrepare);
+				m_lastIndex = index;
 			}
 
-			private void AppendString(string value, int offset, int length)
+			protected override void OnNamedParameter(int index, int length)
 			{
-				m_writer.Write(value, offset, length);
+				var parameterName = m_preparer.m_commandText.Substring(index, length);
+				DoAppendParameter(parameterName, -1, index, length);
+			}
+
+			protected override void OnPositionalParameter(int index)
+			{
+				DoAppendParameter(null, m_currentParameterIndex, index, 1);
+				m_currentParameterIndex++;
+			}
+
+			private void DoAppendParameter(string parameterName, int parameterIndex, int textIndex, int textLength)
+			{
+				// write all SQL up to the parameter
+				m_writer.Write(m_preparer.m_commandText, m_lastIndex, textIndex - m_lastIndex);
+				m_lastIndex = textIndex + textLength;
+
+				// replace the parameter with a ? placeholder
+				m_writer.Write((byte) '?');
+
+				// store the parameter index
+				m_statements[m_statements.Count - 1].ParameterNames.Add(parameterName);
+				m_statements[m_statements.Count - 1].ParameterIndexes.Add(parameterIndex);
+			}
+
+			protected override void OnStatementEnd(int index)
+			{
+				m_writer.Write(m_preparer.m_commandText, m_lastIndex, index - m_lastIndex);
+				m_lastIndex = index;
+				m_statementStartEndIndexes.Add(m_writer.Position);
 			}
 
 			readonly StatementPreparer m_preparer;
+			readonly List<ParsedStatement> m_statements;
+			readonly List<int> m_statementStartEndIndexes;
 			readonly ByteBufferWriter m_writer;
 			int m_currentParameterIndex;
 			int m_lastIndex;
 		}
 
+
 		readonly string m_commandText;
 		readonly MySqlParameterCollection m_parameters;
 		readonly StatementPreparerOptions m_options;

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

@@ -178,7 +178,7 @@ private MySqlParameter(MySqlParameter other, string parameterName)
 
 		internal string NormalizedParameterName { get; private set; }
 
-		internal void AppendSqlString(ByteBufferWriter writer, StatementPreparerOptions options, string parameterName)
+		internal void AppendSqlString(ByteBufferWriter writer, StatementPreparerOptions options)
 		{
 			if (Value == null || Value == DBNull.Value)
 			{
@@ -277,9 +277,9 @@ internal void AppendSqlString(ByteBufferWriter writer, StatementPreparerOptions
 			else if (Value is DateTime dateTimeValue)
 			{
 				if ((options & StatementPreparerOptions.DateTimeUtc) != 0 && dateTimeValue.Kind == DateTimeKind.Local)
-					throw new MySqlException("DateTime.Kind must not be Local when DateTimeKind setting is Utc (parameter name: {0})".FormatInvariant(parameterName));
+					throw new MySqlException("DateTime.Kind must not be Local when DateTimeKind setting is Utc (parameter name: {0})".FormatInvariant(ParameterName));
 				else if ((options & StatementPreparerOptions.DateTimeLocal) != 0 && dateTimeValue.Kind == DateTimeKind.Utc)
-					throw new MySqlException("DateTime.Kind must not be Utc when DateTimeKind setting is Local (parameter name: {0})".FormatInvariant(parameterName));
+					throw new MySqlException("DateTime.Kind must not be Utc when DateTimeKind setting is Local (parameter name: {0})".FormatInvariant(ParameterName));
 
 				writer.Write("timestamp('{0:yyyy'-'MM'-'dd' 'HH':'mm':'ss'.'ffffff}')".FormatInvariant(dateTimeValue));
 			}

src/MySqlConnector/Protocol/CommandKind.cs

@@ -7,6 +7,7 @@ internal enum CommandKind
 		Query = 3,
 		Ping = 14,
 		ChangeUser = 17,
+		StatementPrepare = 22,
 		ResetConnection = 31,
 	}
 }