Implement ChangeDatabase. Fixes #201

bgrainger · bgrainger · commit 9a025d95f5c3 · 2017-03-22T12:46:57.000-07:00
diff --git a/.ci/config/config.compression+ssl.json b/.ci/config/config.compression+ssl.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=127.0.0.1;user id=ssltest;password=test;port=3306;database=mysqltest;ssl mode=required;use compression=true;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/.ci/config/config.compression.json b/.ci/config/config.compression.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=127.0.0.1;user id=mysqltest;password='test;key=\"val';port=3306;database=mysqltest;ssl mode=none;UseCompression=true;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/.ci/config/config.json b/.ci/config/config.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=127.0.0.1;user id=mysqltest;password='test;key=\"val';port=3306;database=mysqltest;ssl mode=none;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/.ci/config/config.ssl.json b/.ci/config/config.ssl.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=127.0.0.1;user id=ssltest;password=test;port=3306;database=mysqltest;ssl mode=required;certificate file=../../../../../.ci/server/certs/ssl-client.pfx;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/.ci/config/config.uds+ssl.json b/.ci/config/config.uds+ssl.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=./../../../../../.ci/mysqld/mysqld.sock;user id=ssltest;password=test;database=mysqltest;ssl mode=required;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/.ci/config/config.uds.json b/.ci/config/config.uds.json
@@ -2,6 +2,7 @@
     "Data": {
       "ConnectionString": "server=./../../../../../.ci/mysqld/mysqld.sock;user id=mysqltest;password='test;key=\"val';database=mysqltest;ssl mode=none;Use Affected Rows=true",
       "PasswordlessUser": "no_password",
+      "SecondaryDatabase": "testdb2",
       "SupportsCachedProcedures": true,
       "SupportsJson": true,
       "MySqlBulkLoaderLocalCsvFile": "%TESTDATA%/LoadData_UTF8_BOM_Unix.CSV",
diff --git a/src/MySqlConnector/MySqlClient/ConnectionPool.cs b/src/MySqlConnector/MySqlClient/ConnectionPool.cs
@@ -58,7 +58,7 @@ public void Return(MySqlSession session)
 		{
 			try
 			{
-				if (session.PoolGeneration == m_generation)
+				if (session.PoolGeneration == m_generation && session.DatabaseOverride == null)
 					m_sessions.Enqueue(session);
 				else
 					session.DisposeAsync(IOBehavior.Synchronous, CancellationToken.None).ConfigureAwait(false);
diff --git a/src/MySqlConnector/MySqlClient/MySqlConnection.cs b/src/MySqlConnector/MySqlClient/MySqlConnection.cs
@@ -86,9 +86,24 @@ public override void EnlistTransaction(System.Transactions.Transaction transacti
 
 		public override void Close() => DoClose();
 
-		public override void ChangeDatabase(string databaseName)
+		public override void ChangeDatabase(string databaseName) => ChangeDatabaseAsync(IOBehavior.Synchronous, databaseName, CancellationToken.None).GetAwaiter().GetResult();
+		public Task ChangeDatabaseAsync(string databaseName) => ChangeDatabaseAsync(IOBehavior.Asynchronous, databaseName, CancellationToken.None);
+		public Task ChangeDatabaseAsync(string databaseName, CancellationToken cancellationToken) => ChangeDatabaseAsync(IOBehavior.Asynchronous, databaseName, CancellationToken.None);
+
+		private async Task ChangeDatabaseAsync(IOBehavior ioBehavior, string databaseName, CancellationToken cancellationToken)
 		{
-			throw new NotImplementedException();
+			if (string.IsNullOrWhiteSpace(databaseName))
+			throw new ArgumentException("Database name is not valid.", nameof(databaseName));
+
+			if (State != ConnectionState.Open)
+				throw new InvalidOperationException("Connection is not open.");
+
+			CloseDatabase();
+
+			await m_session.SendAsync(InitDatabasePayload.Create(databaseName), ioBehavior, cancellationToken).ConfigureAwait(false);
+			var payload = await m_session.ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
+			OkPayload.Create(payload);
+			m_session.DatabaseOverride = databaseName;
 		}
 
 		public override void Open() => OpenAsync(IOBehavior.Synchronous, CancellationToken.None).GetAwaiter().GetResult();
@@ -142,7 +157,7 @@ public override string ConnectionString
 			}
 		}
 
-		public override string Database => m_connectionSettings.Database;
+		public override string Database => m_session.DatabaseOverride ?? m_connectionSettings.Database;
 
 		public override ConnectionState State => m_connectionState;
 
@@ -280,16 +295,7 @@ private void DoClose()
 		{
 			if (m_connectionState != ConnectionState.Closed)
 			{
-				m_cachedProcedures = null;
-				if (ActiveReader != null){
-					ActiveReader.Dispose();
-					ActiveReader = null;
-				}
-				if (CurrentTransaction != null)
-				{
-					CurrentTransaction.Dispose();
-					CurrentTransaction = null;
-				}
+				CloseDatabase();
 				if (m_session != null)
 				{
 					if (m_connectionSettings.Pooling)
@@ -302,6 +308,21 @@ private void DoClose()
 			}
 		}
 
+		private void CloseDatabase()
+		{
+			m_cachedProcedures = null;
+			if (ActiveReader != null)
+			{
+				ActiveReader.Dispose();
+				ActiveReader = null;
+			}
+			if (CurrentTransaction != null)
+			{
+				CurrentTransaction.Dispose();
+				CurrentTransaction = null;
+			}
+		}
+
 		MySqlConnectionStringBuilder m_connectionStringBuilder;
 		ConnectionSettings m_connectionSettings;
 		MySqlSession m_session;
diff --git a/src/MySqlConnector/Serialization/InitDatabasePayload.cs b/src/MySqlConnector/Serialization/InitDatabasePayload.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Text;
+
+namespace MySql.Data.Serialization
+{
+	internal class InitDatabasePayload
+	{
+		public static PayloadData Create(string databaseName)
+		{
+			var writer = new PayloadWriter();
+
+			writer.WriteByte((byte) CommandKind.InitDatabase);
+			writer.Write(Encoding.UTF8.GetBytes(databaseName));
+
+			return new PayloadData(new ArraySegment<byte>(writer.ToBytes()));
+		}
+	}
+}
diff --git a/src/MySqlConnector/Serialization/MySqlSession.cs b/src/MySqlConnector/Serialization/MySqlSession.cs
@@ -32,6 +32,7 @@ public MySqlSession(ConnectionPool pool, int poolGeneration)
 		public byte[] AuthPluginData { get; set; }
 		public ConnectionPool Pool { get; }
 		public int PoolGeneration { get; }
+		public string DatabaseOverride { get; set; }
 
 		public void ReturnToPool() => Pool?.Return(this);
 
diff --git a/tests/SideBySide/AppConfig.cs b/tests/SideBySide/AppConfig.cs
@@ -49,6 +49,8 @@ public static IConfiguration Config
 
 		public static string PasswordlessUser => Config.GetValue<string>("Data:PasswordlessUser");
 
+		public static string SecondaryDatabase => Config.GetValue<string>("Data:SecondaryDatabase");
+
 		public static bool SupportsCachedProcedures => Config.GetValue<bool>("Data:SupportsCachedProcedures");
 
 		public static bool SupportsJson => Config.GetValue<bool>("Data:SupportsJson");
diff --git a/tests/SideBySide/Attributes.cs b/tests/SideBySide/Attributes.cs
@@ -77,6 +77,15 @@ public TcpConnectionFactAttribute()
 		}
 	}
 
+	public class SecondaryDatabaseRequiredFactAttribute : FactAttribute
+	{
+		public SecondaryDatabaseRequiredFactAttribute()
+		{
+			if (string.IsNullOrEmpty(AppConfig.SecondaryDatabase))
+				Skip = "No SecondaryDatabase specified.";
+		}
+	}
+
 	public class SslRequiredConnectionFactAttribute : FactAttribute
 	{
 		public SslRequiredConnectionFactAttribute()
diff --git a/tests/SideBySide/ConnectAsync.cs b/tests/SideBySide/ConnectAsync.cs
@@ -1,4 +1,5 @@
-﻿using System.Data;
+﻿using System;
+using System.Data;
 using System.IO;
 using System.Threading.Tasks;
 using MySql.Data.MySqlClient;
@@ -178,6 +179,103 @@ public async Task ConnectSslBadClientCertificate()
 			}
 		}
 
+		[SecondaryDatabaseRequiredFact]
+		public async Task ChangeDatabase()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				await connection.OpenAsync();
+
+				Assert.Equal(csb.Database, connection.Database);
+				Assert.Equal(csb.Database, await QueryCurrentDatabaseAsync(connection));
+
+				await connection.ChangeDatabaseAsync(AppConfig.SecondaryDatabase);
+
+				Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
+				Assert.Equal(AppConfig.SecondaryDatabase, await QueryCurrentDatabaseAsync(connection));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public async Task ChangeDatabaseNotOpen()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				await Assert.ThrowsAsync<InvalidOperationException>(() => connection.ChangeDatabaseAsync(AppConfig.SecondaryDatabase));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public async Task ChangeDatabaseNull()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				await Assert.ThrowsAsync<ArgumentException>(() => connection.ChangeDatabaseAsync(null));
+				await Assert.ThrowsAsync<ArgumentException>(() => connection.ChangeDatabaseAsync(""));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public async Task ChangeDatabaseInvalidName()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				connection.Open();
+
+				await Assert.ThrowsAsync<MySqlException>(() => connection.ChangeDatabaseAsync($"not_a_real_database_1234"));
+
+				Assert.Equal(ConnectionState.Open, connection.State);
+				Assert.Equal(csb.Database, connection.Database);
+				Assert.Equal(csb.Database, await QueryCurrentDatabaseAsync(connection));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public async Task ChangeDatabaseConnectionPooling()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			csb.Pooling = true;
+			csb.MinimumPoolSize = 0;
+			csb.MaximumPoolSize = 6;
+
+			for (int i = 0; i < csb.MaximumPoolSize * 2; i++)
+			{
+				using (var connection = new MySqlConnection(csb.ConnectionString))
+				{
+					await connection.OpenAsync();
+
+					Assert.Equal(csb.Database, connection.Database);
+					Assert.Equal(csb.Database, await QueryCurrentDatabaseAsync(connection));
+
+					await connection.ChangeDatabaseAsync(AppConfig.SecondaryDatabase);
+
+					Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
+					Assert.Equal(AppConfig.SecondaryDatabase, await QueryCurrentDatabaseAsync(connection));
+				}
+			}
+		}
+
+		private static async Task<string> QueryCurrentDatabaseAsync(MySqlConnection connection)
+		{
+			using (var cmd = connection.CreateCommand())
+			{
+				cmd.CommandText = "SELECT DATABASE()";
+				return (string) await cmd.ExecuteScalarAsync();
+			}
+		}
+
 		readonly DatabaseFixture m_database;
 	}
+
+#if BASELINE
+	internal static class BaselineConnectionHelpers
+	{
+		// Baseline connector capitalizes the 'B' in 'Database'
+		public static Task ChangeDatabaseAsync(this MySqlConnection connection, string databaseName) => connection.ChangeDataBaseAsync(databaseName);
+	}
+#endif
 }
diff --git a/tests/SideBySide/ConnectSync.cs b/tests/SideBySide/ConnectSync.cs
@@ -184,6 +184,95 @@ public void ConnectTimeout()
 			}
 		}
 
+		[SecondaryDatabaseRequiredFact]
+		public void ChangeDatabase()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				connection.Open();
+
+				Assert.Equal(csb.Database, connection.Database);
+				Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
+
+				connection.ChangeDatabase(AppConfig.SecondaryDatabase);
+
+				Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
+				Assert.Equal(AppConfig.SecondaryDatabase, QueryCurrentDatabase(connection));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public void ChangeDatabaseNotOpen()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				Assert.Throws<InvalidOperationException>(() => connection.ChangeDatabase(AppConfig.SecondaryDatabase));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public void ChangeDatabaseNull()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				Assert.Throws<ArgumentException>(() => connection.ChangeDatabase(null));
+				Assert.Throws<ArgumentException>(() => connection.ChangeDatabase(""));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public void ChangeDatabaseInvalidName()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			using (var connection = new MySqlConnection(csb.ConnectionString))
+			{
+				connection.Open();
+
+				Assert.Throws<MySqlException>(() => connection.ChangeDatabase($"not_a_real_database_1234"));
+
+				Assert.Equal(ConnectionState.Open, connection.State);
+				Assert.Equal(csb.Database, connection.Database);
+				Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
+			}
+		}
+
+		[SecondaryDatabaseRequiredFact]
+		public void ChangeDatabaseConnectionPooling()
+		{
+			var csb = AppConfig.CreateConnectionStringBuilder();
+			csb.Pooling = true;
+			csb.MinimumPoolSize = 0;
+			csb.MaximumPoolSize = 6;
+
+			for (int i = 0; i < csb.MaximumPoolSize * 2; i++)
+			{
+				using (var connection = new MySqlConnection(csb.ConnectionString))
+				{
+					connection.Open();
+
+					Assert.Equal(csb.Database, connection.Database);
+					Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
+
+					connection.ChangeDatabase(AppConfig.SecondaryDatabase);
+
+					Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
+					Assert.Equal(AppConfig.SecondaryDatabase, QueryCurrentDatabase(connection));
+				}
+			}
+		}
+
+		private static string QueryCurrentDatabase(MySqlConnection connection)
+		{
+			using (var cmd = connection.CreateCommand())
+			{
+				cmd.CommandText = "SELECT DATABASE()";
+				return (string) cmd.ExecuteScalar();
+			}
+		}
+
 		readonly DatabaseFixture m_database;
 	}
 }
diff --git a/tests/SideBySide/DatabaseFixture.cs b/tests/SideBySide/DatabaseFixture.cs

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public void Return(MySqlSession session)`
`58`	`58`	`{`
`59`	`59`	`try`
`60`	`60`	`{`
`61`		`- if (session.PoolGeneration == m_generation)`
	`61`	`+ if (session.PoolGeneration == m_generation && session.DatabaseOverride == null)`
`62`	`62`	`m_sessions.Enqueue(session);`
`63`	`63`	`else`
`64`	`64`	`session.DisposeAsync(IOBehavior.Synchronous, CancellationToken.None).ConfigureAwait(false);`