Merge master into net6.

Author: bgrainger

docs/content/api/MySqlConnector/MySqlErrorCodeType.md

@@ -660,6 +660,8 @@ public enum MySqlErrorCode
 | DebugSyncTimeout | `1639` | ER_DEBUG_SYNC_TIMEOUT |
 | DebugSyncHitLimit | `1640` | ER_DEBUG_SYNC_HIT_LIMIT |
 | CannotExecuteInReadOnlyTransaction | `1792` | ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION |
+| CannotConvertString | `3854` | ER_CANNOT_CONVERT_STRING |
+| ClientInteractionTimeout | `4031` | ER_CLIENT_INTERACTION_TIMEOUT |
 
 ## See Also
 

docs/content/overview/schema-collections.md

@@ -0,0 +1,45 @@
+---
+date: 2021-04-24
+menu:
+  main:
+    parent: getting started
+title: Schema Collections
+customtitle: "Supported Schema Collections"
+weight: 80
+---
+
+# Supported Schema Collections
+
+`DbConnection.GetSchema` retrieves schema information about the database that is currently connected. For background, see MSDN on [GetSchema and Schema Collections](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/getschema-and-schema-collections) and [Common Schema Collections](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/common-schema-collections).
+
+`MySqlConnection.GetSchema` supports the following schemas:
+
+* `MetaDataCollections`—information about available schemas
+* `CharacterSets`
+* `Collations`
+* `CollationCharacterSetApplicability`
+* `Columns`
+* `Databases`
+* `DataTypes`—information about available data types
+* `Engines`
+* `KeyColumnUsage`
+* `KeyWords`
+* `Parameters`
+* `Partitions`
+* `Plugins`
+* `Procedures`—information about stored procedures
+* `ProcessList`
+* `Profiling`
+* `ReferentialConstraints`
+* `ReservedWords`—information about reserved words in the server's SQL syntax
+* `ResourceGroups`
+* `SchemaPrivileges`
+* `Tables`
+* `TableConstraints`
+* `TablePrivileges`
+* `TableSpaces`
+* `Triggers`
+* `UserPrivileges`
+* `Views`
+
+The `GetSchema(string, string[])` overload that specifies restrictions is not supported.

docs/content/overview/use-with-orms.md

@@ -14,6 +14,7 @@ Use with ORMs
 This library is compatible with popular .NET ORMs including:
 
 * [Dapper](https://stackexchange.github.io/Dapper/) ([GitHub](https://github.com/StackExchange/dapper-dot-net), [NuGet](https://www.nuget.org/packages/Dapper))
+* [FreeSql](http://freesql.net/) ([GitHub](https://github.com/dotnetcore/FreeSql), [NuGet](https://www.nuget.org/packages/FreeSql.Provider.MySqlConnector/))
 * [LINQ to DB](https://linq2db.github.io) ([GitHub](https://github.com/linq2db/linq2db), [NuGet](https://www.nuget.org/packages/linq2db.MySqlConnector))
 * [NHibernate](https://www.nhibernate.info) ([GitHub](https://github.com/nhibernate/NHibernate.MySqlConnector), [NuGet](https://www.nuget.org/packages/NHibernate.Driver.MySqlConnector))
 * [NReco.Data](https://www.nrecosite.com/dalc_net.aspx) ([GitHub](https://github.com/nreco/data), [NuGet](https://www.nuget.org/packages/NReco.Data))

docs/content/overview/version-history.md

@@ -1,5 +1,5 @@
 ---
-lastmod: 2021-04-24
+lastmod: 2021-04-30
 date: 2017-03-27
 menu:
   main:
@@ -10,6 +10,10 @@ weight: 30
 
 # Version History
 
+### 1.3.8
+
+* Reduce latency of resetting connections: [#982](https://github.com/mysql-net/MySqlConnector/pull/982).
+
 ### 1.3.7
 
 * Add support for [SingleStore](https://www.singlestore.com/): [#968](https://github.com/mysql-net/MySqlConnector/pull/968).

docs/content/troubleshooting/connection-reuse.md

@@ -21,41 +21,54 @@ an open `MySqlDataReader`.
 You may not execute multiple operations in parallel, for example:
 
 ```csharp
-using (var connection = new MySqlConnection("..."))
-{
-    await connection.OpenAsync();
-    await Task.WhenAll( // don't do this
-        connection.ExecuteAsync("SELECT 1;"),
-        connection.ExecuteAsync("SELECT 2;"),
-        connection.ExecuteAsync("SELECT 3;"));
-}
+using var connection = new MySqlConnection("...");
+await connection.OpenAsync();
+await Task.WhenAll( // don't do this
+    connection.ExecuteAsync("SELECT 1;"),
+    connection.ExecuteAsync("SELECT 2;"),
+    connection.ExecuteAsync("SELECT 3;"));
 ```
 
 ### Nested Access on Single Thread
 
 You may not reuse the connection when there is an open `MySqlDataReader:`
 
 ```csharp
-using (var connection = CreateOpenConnection())
-using (var command = new MySqlCommand("SELECT id FROM ...", connection))
-using (var reader = command.ExecuteReader())
+using var connection = CreateOpenConnection();
+using var command = new MySqlCommand("SELECT id FROM ...", connection);
+using var reader = command.ExecuteReader();
+while (reader.Read())
 {
-    while (reader.Read())
-    {
-        var idToUpdate = reader.GetValue(0);
-        connection.Execute("UPDATE ... SET ..."); // don't do this
-    }
+    var idToUpdate = reader.GetValue(0);
+    connection.Execute("UPDATE ... SET ..."); // don't do this
 }
 ```
 
+### Dispose While in Use
+
+You may not `Dispose` any MySqlConnector objects while they are in use:
+
+```csharp
+var connection = new MySqlConnection("...");
+await connection.OpenAsync();
+var command = new MySqlCommand("SELECT SLEEP(1)", connection);
+var task = command.ExecuteScalarAsync();
+connection.Dispose(); // don't do this
+command.Dispose();
+await task;
+```
+
 ## How to Fix
 
 For the multithreaded scenario, if concurrent access to the database is truly necessary,
 create and open a new `MySqlConnection` on each thread. But in most cases, you should
 just write code that sequentially `await`s each asychronous operation (without performing
 them in parallel).
 
-
 For the nested access, read all the values from the `MySqlDataReader` into memory, close
 the reader, then process the values. (If the data set is large, you may need to use a batching
-approach where you read a limited number of rows in each batch.)
+approach where you read a limited number of rows in each batch.)
+
+For lifetime management, prefer to use `using` (or `await using`) instead of explicitly
+calling `Dispose` (or `DisposeAsync`). Ensure that all outstanding operations have
+completed before disposing objects that are in use.

docs/content/troubleshooting/load-data-local-infile.md

@@ -32,7 +32,7 @@ If you do this, you may receive one of the following errors:
 malicious server or proxy could send a fake “local infile request” packet to the client and
 read any file that the client has permission to open.
 
-For more information, see [the MySQL documentation](https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html).
+For more information, see [the MySQL documentation](https://dev.mysql.com/doc/refman/8.0/en/load-data-local-security.html).
 
 ## How to Fix
 

src/MySqlConnector/Core/BackgroundConnectionResetHelper.cs

@@ -11,12 +11,12 @@ internal static class BackgroundConnectionResetHelper
 	{
 		public static void AddSession(ServerSession session, MySqlConnection? owningConnection)
 		{
-			var resetTask = session.TryResetConnectionAsync(session.Pool!.ConnectionSettings, IOBehavior.Asynchronous, default);
+			var resetTask = session.TryResetConnectionAsync(session.Pool!.ConnectionSettings, owningConnection, true, IOBehavior.Asynchronous, default);
 			lock (s_lock)
-				s_sessions.Add(new SessionResetTask(session, resetTask, owningConnection));
+				s_resetTasks.Add(resetTask);
 
 			if (Log.IsDebugEnabled())
-				Log.Debug("Started Session{0} reset in background; waiting SessionCount: {1}.", session.Id, s_sessions.Count);
+				Log.Debug("Started Session{0} reset in background; waiting TaskCount: {1}.", session.Id, s_resetTasks.Count);
 
 			// release only if it is likely to succeed
 			if (s_semaphore.CurrentCount == 0)
@@ -69,7 +69,6 @@ public static async Task ReturnSessionsAsync()
 			Log.Info("Started BackgroundConnectionResetHelper worker.");
 
 			List<Task<bool>> localTasks = new();
-			List<SessionResetTask> localSessions = new();
 
 			// keep running until stopped
 			while (!s_cancellationTokenSource.IsCancellationRequested)
@@ -85,36 +84,18 @@ public static async Task ReturnSessionsAsync()
 					{
 						lock (s_lock)
 						{
-							if (s_sessions.Count == 0)
-							{
-								if (localTasks.Count == 0)
-									break;
-							}
-							else
-							{
-								foreach (var session in s_sessions)
-								{
-									localSessions.Add(session);
-									localTasks.Add(session.ResetTask);
-								}
-								s_sessions.Clear();
-							}
+							localTasks.AddRange(s_resetTasks);
+							s_resetTasks.Clear();
 						}
 
+						if (localTasks.Count == 0)
+							break;
+
 						if (Log.IsDebugEnabled())
-							Log.Debug("Found SessionCount {0} session(s) to return.", localSessions.Count);
+							Log.Debug("Found TaskCount {0} task(s) to process.", localTasks.Count);
 
-						while (localTasks.Count != 0)
-						{
-							var completedTask = await Task.WhenAny(localTasks).ConfigureAwait(false);
-							var index = localTasks.IndexOf(completedTask);
-							var session = localSessions[index].Session;
-							var connection = localSessions[index].OwningConnection;
-							localSessions.RemoveAt(index);
-							localTasks.RemoveAt(index);
-							await session.Pool!.ReturnAsync(IOBehavior.Asynchronous, session).ConfigureAwait(false);
-							GC.KeepAlive(connection);
-						}
+						await Task.WhenAll(localTasks);
+						localTasks.Clear();
 					}
 				}
 				catch (Exception ex) when (!(ex is OperationCanceledException oce && oce.CancellationToken == s_cancellationTokenSource.Token))
@@ -124,25 +105,11 @@ public static async Task ReturnSessionsAsync()
 			}
 		}
 
-		internal readonly struct SessionResetTask
-		{
-			public SessionResetTask(ServerSession session, Task<bool> resetTask, MySqlConnection? owningConnection)
-			{
-				Session = session;
-				ResetTask = resetTask;
-				OwningConnection = owningConnection;
-			}
-
-			public ServerSession Session { get; }
-			public Task<bool> ResetTask { get; }
-			public MySqlConnection? OwningConnection { get; }
-		}
-
 		static readonly IMySqlConnectorLogger Log = MySqlConnectorLogManager.CreateLogger(nameof(BackgroundConnectionResetHelper));
 		static readonly object s_lock = new();
 		static readonly SemaphoreSlim s_semaphore = new(1, 1);
 		static readonly CancellationTokenSource s_cancellationTokenSource = new();
-		static readonly List<SessionResetTask> s_sessions = new();
+		static readonly List<Task<bool>> s_resetTasks = new();
 		static Task? s_workerTask;
 	}
 }

src/MySqlConnector/Core/ConnectionPool.cs

@@ -68,7 +68,7 @@ public async ValueTask<ServerSession> GetSessionAsync(MySqlConnection connection
 					{
 						if ((ConnectionSettings.ConnectionReset && ConnectionSettings.DeferConnectionReset) || session.DatabaseOverride is not null)
 						{
-							reuseSession = await session.TryResetConnectionAsync(ConnectionSettings, ioBehavior, cancellationToken).ConfigureAwait(false);
+							reuseSession = await session.TryResetConnectionAsync(ConnectionSettings, null, false, ioBehavior, cancellationToken).ConfigureAwait(false);
 						}
 						else if ((unchecked((uint) Environment.TickCount) - session.LastReturnedTicks) >= ConnectionSettings.ConnectionIdlePingTime)
 						{
@@ -158,7 +158,11 @@ private int GetSessionHealth(ServerSession session)
 			return 0;
 		}
 
-		public async Task ReturnAsync(IOBehavior ioBehavior, ServerSession session)
+#if NET45 || NET461 || NET471 || NETSTANDARD1_3 || NETSTANDARD2_0
+		public async ValueTask<int> ReturnAsync(IOBehavior ioBehavior, ServerSession session)
+#else
+		public async ValueTask ReturnAsync(IOBehavior ioBehavior, ServerSession session)
+#endif
 		{
 			if (Log.IsDebugEnabled())
 				Log.Debug("Pool{0} receiving Session{1} back", m_logArguments[0], session.Id);
@@ -188,6 +192,10 @@ public async Task ReturnAsync(IOBehavior ioBehavior, ServerSession session)
 			{
 				m_sessionSemaphore.Release();
 			}
+
+#if NET45 || NET461 || NET471 || NETSTANDARD1_3 || NETSTANDARD2_0
+			return default;
+#endif
 		}
 
 		public async Task ClearAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)

src/MySqlConnector/Core/ServerSession.cs

@@ -68,7 +68,11 @@ public ServerSession(ConnectionPool? pool, int poolGeneration, int id)
 		public bool SupportsSessionTrack => m_supportsSessionTrack;
 		public bool ProcAccessDenied { get; set; }
 
-		public Task ReturnToPoolAsync(IOBehavior ioBehavior, MySqlConnection? owningConnection)
+#if NET45 || NET461 || NET471 || NETSTANDARD1_3 || NETSTANDARD2_0
+		public ValueTask<int> ReturnToPoolAsync(IOBehavior ioBehavior, MySqlConnection? owningConnection)
+#else
+		public ValueTask ReturnToPoolAsync(IOBehavior ioBehavior, MySqlConnection? owningConnection)
+#endif
 		{
 			if (Log.IsDebugEnabled())
 			{
@@ -77,11 +81,11 @@ public Task ReturnToPoolAsync(IOBehavior ioBehavior, MySqlConnection? owningConn
 			}
 			LastReturnedTicks = unchecked((uint) Environment.TickCount);
 			if (Pool is null)
-				return Utility.CompletedTask;
+				return default;
 			if (!Pool.ConnectionSettings.ConnectionReset || Pool.ConnectionSettings.DeferConnectionReset)
 				return Pool.ReturnAsync(ioBehavior, this);
 			BackgroundConnectionResetHelper.AddSession(this, owningConnection);
-			return Utility.CompletedTask;
+			return default;
 		}
 
 		public bool IsConnected
@@ -529,10 +533,11 @@ public async Task DisposeAsync(IOBehavior ioBehavior, CancellationToken cancella
 			return statusInfo;
 		}
 
-		public async Task<bool> TryResetConnectionAsync(ConnectionSettings cs, IOBehavior ioBehavior, CancellationToken cancellationToken)
+		public async Task<bool> TryResetConnectionAsync(ConnectionSettings cs, MySqlConnection? owningConnection, bool returnToPool, IOBehavior ioBehavior, CancellationToken cancellationToken)
 		{
 			VerifyState(State.Connected);
 
+			var success = false;
 			try
 			{
 				// clear all prepared statements; resetting the connection will clear them on the server
@@ -578,7 +583,7 @@ public async Task<bool> TryResetConnectionAsync(ConnectionSettings cs, IOBehavio
 				payload = await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
 				OkPayload.Create(payload.Span, SupportsDeprecateEof, SupportsSessionTrack);
 
-				return true;
+				success = true;
 			}
 			catch (IOException ex)
 			{
@@ -597,7 +602,15 @@ public async Task<bool> TryResetConnectionAsync(ConnectionSettings cs, IOBehavio
 				Log.Debug(ex, "Session{0} ignoring SocketException in TryResetConnectionAsync", m_logArguments);
 			}
 
-			return false;
+			if (returnToPool && Pool is not null)
+			{
+				await Pool.ReturnAsync(ioBehavior, this).ConfigureAwait(false);
+
+				// make sure the MySqlConnection is kept alive until the session is returned to the pool; this prevents it from potentially being detected as "leaked"
+				GC.KeepAlive(owningConnection);
+			}
+
+			return success;
 		}
 
 		private async Task<PayloadData> SwitchAuthenticationAsync(ConnectionSettings cs, PayloadData payload, IOBehavior ioBehavior, CancellationToken cancellationToken)

src/MySqlConnector/MySqlBulkCopy.cs

@@ -622,13 +622,13 @@ static bool WriteSubstring(string value, ref int inputIndex, ref Encoder? utf8En
 
 						utf8Encoder ??= s_utf8Encoding.GetEncoder();
 #if NETSTANDARD1_3
-						if (output.Length <= 4 && utf8Encoder.GetByteCount(value.ToCharArray(), inputIndex, 1, flush: false) > output.Length)
+						if (output.Length < 4 && utf8Encoder.GetByteCount(value.ToCharArray(), inputIndex, Math.Min(2, nextIndex - inputIndex), flush: false) > output.Length)
 							return false;
 						var buffer = new byte[output.Length];
 						utf8Encoder.Convert(value.ToCharArray(), inputIndex, nextIndex - inputIndex, buffer, 0, buffer.Length, nextIndex == value.Length, out var charsUsed, out var bytesUsed, out var completed);
 						buffer.AsSpan().CopyTo(output);
 #else
-						if (output.Length <= 4 && utf8Encoder.GetByteCount(value.AsSpan(inputIndex, 1), flush: false) > output.Length)
+						if (output.Length < 4 && utf8Encoder.GetByteCount(value.AsSpan(inputIndex, Math.Min(2, nextIndex - inputIndex)), flush: false) > output.Length)
 							return false;
 						utf8Encoder.Convert(value.AsSpan(inputIndex, nextIndex - inputIndex), output, nextIndex == value.Length, out var charsUsed, out var bytesUsed, out var completed);
 #endif