public void ConnectionStringExpiry()
{
executeSQL("CREATE TABLE test3 (id INT, name VARCHAR(20), name2 VARCHAR(20))");
executeSQL("INSERT INTO test3 VALUES (1, 'boo', 'hoo'), (2, 'first', 'last'), (3, 'fred', 'flintstone')");
#if !NETCOREAPP1_1
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = Connection.ConnectionString + ";logging=true;table cache=true;default table cache age=1";
#else
string connStr = Connection.ConnectionString + ";table cache=true;default table cache age=1";
#endif
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlCommand cmd = new MySqlCommand("test3", c);
cmd.CommandType = CommandType.TableDirect;
ConsumeReader(cmd);
Thread.Sleep(1500);
// now run the query again but this time it should generate a call to the database
// since our next query is past the cache age of 1 second
ConsumeReader(cmd);
}
#if !NETCOREAPP1_1
Assert.Equal(2, listener.Find("Resultset Opened: field(s) = 3"));
#endif
}
public void BatchUpdatesAndDeletes()
{
st.execSQL("CREATE TABLE test (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(20))");
st.execSQL("INSERT INTO test VALUES (1, 'boo'), (2, 'boo'), (3, 'boo')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = st.GetConnectionString(true) + ";logging=true;allow batch=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlDataAdapter da = new MySqlDataAdapter("SELECT * FROM test", c);
MySqlCommandBuilder cb = new MySqlCommandBuilder(da);
da.UpdateCommand = cb.GetUpdateCommand();
da.UpdateCommand.UpdatedRowSource = UpdateRowSource.None;
da.UpdateBatchSize = 100;
DataTable dt = new DataTable();
da.Fill(dt);
dt.Rows[0]["name"] = "boo2";
dt.Rows[1]["name"] = "boo2";
dt.Rows[2]["name"] = "boo2";
da.Update(dt);
}
Assert.Equal(1, listener.Find("Query Opened: UPDATE"));
}
public void MultipleThreads()
{
GenericListener myListener = new GenericListener();
ManualResetEvent ev = new ManualResetEvent(false);
ArrayList threads = new ArrayList();
System.Diagnostics.Trace.Listeners.Add(myListener);
for (int i = 0; i < 20; i++)
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(MultipleThreadsWorker);
Thread t = new Thread(ts);
threads.Add(t);
t.Start(ev);
}
// now let the threads go
ev.Set();
// wait for the threads to end
int x = 0;
while (x < threads.Count)
{
while ((threads[x] as Thread).IsAlive)
{
Thread.Sleep(50);
}
x++;
}
}
public void SettingAgeOnCommand()
{
execSQL("CREATE TABLE test2 (id INT, name VARCHAR(20), name2 VARCHAR(20))");
execSQL("INSERT INTO test2 VALUES (1, 'boo', 'hoo'), (2, 'first', 'last'), (3, 'fred', 'flintstone')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = GetConnectionString(true) + ";logging=true;table cache=true;default table cache age=1";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlCommand cmd = new MySqlCommand("test2", c);
cmd.CommandType = CommandType.TableDirect;
cmd.CacheAge = 20;
ConsumeReader(cmd);
Thread.Sleep(1000);
// now run the query again but this time it shouldn't generate a call to the database
// since we have overriden the connection string cache age of 1 second and set it
// to 20 seconds on our command
ConsumeReader(cmd);
}
Assert.AreEqual(1, listener.Find("Resultset Opened: field(s) = 3"));
}
public void ProviderNormalizingQuery()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
StringBuilder sql = new StringBuilder("SELECT '");
for (int i = 0; i < 400; i++)
{
sql.Append("a");
}
sql.Append("'");
using (var logConn = new MySqlConnection(Connection.ConnectionString + ";logging=true"))
{
logConn.Open();
MySqlCommand cmd = new MySqlCommand(sql.ToString(), logConn);
cmd.ExecuteNonQuery();
}
Assert.AreEqual(28, listener.Strings.Count);
StringAssert.EndsWith("SELECT ?", listener.Strings[listener.Strings.Count - 5]);
}
public void FieldConversion()
{
_fixture.execSQL("INSERT INTO Test VALUES (1, 'Test1')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test", _fixture.conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
short s = reader.GetInt16(0);
long l = reader.GetInt64(0);
string str = reader.GetString(1);
}
Assert.Equal(6, listener.Strings.Count);
Assert.True(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test"));
Assert.True(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.True(listener.Strings[3].Contains("Usage Advisor Warning: The field 'id' was converted to the following types: Int16,Int64"));
Assert.True(listener.Strings[4].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=8"));
Assert.True(listener.Strings[5].Contains("Query Closed"));
}
public void SimpleLogging()
{
ExecuteSQL("CREATE TABLE Test(id INT, name VARCHAR(200))");
ExecuteSQL("INSERT INTO Test VALUES (1, 'Test1')");
ExecuteSQL("INSERT INTO Test VALUES (2, 'Test2')");
ExecuteSQL("INSERT INTO Test VALUES (3, 'Test3')");
ExecuteSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
using (var logConn = new MySqlConnection(Connection.ConnectionString + ";logging=true"))
{
logConn.Open();
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test", logConn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
}
//Assert.AreEqual(4, listener.Strings.Count);
Assert.AreEqual(27, listener.Strings.Count);
StringAssert.Contains("Query Opened: SELECT * FROM Test", listener.Strings[listener.Strings.Count - 5]);
StringAssert.Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1", listener.Strings[listener.Strings.Count - 4]);
StringAssert.Contains("Resultset Closed. Total rows=4, skipped rows=4, size (bytes)=32", listener.Strings[listener.Strings.Count - 3]);
StringAssert.Contains("Query Closed", listener.Strings[listener.Strings.Count - 2]);
}
public void Warnings()
{
_fixture.execSQL("DROP TABLE IF EXISTS Test");
_fixture.execSQL("CREATE TABLE Test(id INT, name VARCHAR(5))");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
using (MySqlConnection logConnection = new MySqlConnection(this.conn))
{
logConnection.Open();
MySqlCommand cmd = new MySqlCommand("INSERT IGNORE INTO Test VALUES (1, 'abcdef')", logConnection);
cmd.ExecuteNonQuery();
}
Assert.Equal(32, listener.Strings.Count);
Assert.True(listener.Strings[listener.Strings.Count - 10].Contains("Query Opened: INSERT IGNORE INTO Test VALUES (1, 'abcdef')"));
Assert.True(listener.Strings[listener.Strings.Count - 9].Contains("Resultset Opened: field(s) = 0, affected rows = 1, inserted id = 0"));
Assert.True(listener.Strings[listener.Strings.Count - 8].Contains("Resultset Closed. Total rows=0, skipped rows=0, size (bytes)=0"));
Assert.True(listener.Strings[listener.Strings.Count - 7].Contains("Query Opened: SHOW WARNINGS"));
Assert.True(listener.Strings[listener.Strings.Count - 6].Contains("Resultset Opened: field(s) = 3, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[listener.Strings.Count - 5].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=55"));
Assert.True(listener.Strings[listener.Strings.Count - 4].Contains("Query Closed"));
Assert.True(listener.Strings[listener.Strings.Count - 3].Contains("MySql Warning: Level=Warning, Code=1265, Message=Data truncated for column 'name' at row 1"));
Assert.True(listener.Strings[listener.Strings.Count - 2].Contains("Query Closed"));
}
public void SimpleTableCaching()
{
_fixture.execSQL("CREATE TABLE test (id INT, name VARCHAR(20), name2 VARCHAR(20))");
_fixture.execSQL("INSERT INTO test VALUES (1, 'boo', 'hoo'), (2, 'first', 'last'), (3, 'fred', 'flintstone')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = _fixture.GetConnectionString(true) + ";logging=true;table cache=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlCommand cmd = new MySqlCommand("test", c);
cmd.CommandType = CommandType.TableDirect;
ConsumeReader(cmd);
// now run the query again but this time it shouldn't generate a call to the database
ConsumeReader(cmd);
}
Assert.Equal(1, listener.Find("Resultset Opened: field(s) = 3"));
}
public void Warnings()
{
execSQL("DROP TABLE IF EXISTS Test");
execSQL("CREATE TABLE Test(id INT, name VARCHAR(5))");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("INSERT IGNORE INTO Test VALUES (1, 'abcdef')", conn);
cmd.ExecuteNonQuery();
Assert.AreEqual(9, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: INSERT IGNORE INTO Test VALUES (1, 'abcdef')"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 0, affected rows = 1, inserted id = 0"));
Assert.IsTrue(listener.Strings[2].Contains("Resultset Closed. Total rows=0, skipped rows=0, size (bytes)=0"));
Assert.IsTrue(listener.Strings[3].Contains("Query Opened: SHOW WARNINGS"));
Assert.IsTrue(listener.Strings[4].Contains("Resultset Opened: field(s) = 3, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[5].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=55"));
Assert.IsTrue(listener.Strings[6].Contains("Query Closed"));
Assert.IsTrue(listener.Strings[7].Contains("MySql Warning: Level=Warning, Code=1265, Message=Data truncated for column 'name' at row 1"));
Assert.IsTrue(listener.Strings[8].Contains("Query Closed"));
}
public void NoIndexUsed()
{
ExecuteSQL("CREATE TABLE Test (id int, name VARCHAR(200))");
ExecuteSQL("INSERT INTO Test VALUES (1, 'Test1')");
ExecuteSQL("INSERT INTO Test VALUES (2, 'Test1')");
ExecuteSQL("INSERT INTO Test VALUES (3, 'Test1')");
ExecuteSQL("INSERT INTO Test VALUES (4, 'Test1')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT name FROM Test WHERE id=3", Connection);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
}
Assert.AreEqual(6, listener.Strings.Count);
StringAssert.Contains("Query Opened: SELECT name FROM Test WHERE id=3", listener.Strings[0]);
StringAssert.Contains("Resultset Opened: field(s) = 1, affected rows = -1, inserted id = -1", listener.Strings[1]);
StringAssert.Contains("Usage Advisor Warning: Query does not use an index", listener.Strings[2]);
StringAssert.Contains("Usage Advisor Warning: The following columns were not accessed: name", listener.Strings[3]);
StringAssert.Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=6", listener.Strings[4]);
StringAssert.Contains("Query Closed", listener.Strings[5]);
}
public void BadIndexUsed()
{
_fixture.execSQL("DROP TABLE IF EXISTS Test");
_fixture.execSQL("CREATE TABLE Test(id INT, name VARCHAR(20) PRIMARY KEY)");
_fixture.execSQL("INSERT INTO Test VALUES (1, 'Test1')");
_fixture.execSQL("INSERT INTO Test VALUES (2, 'Test2')");
_fixture.execSQL("INSERT INTO Test VALUES (3, 'Test3')");
_fixture.execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT name FROM Test WHERE id=3", _fixture.conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
}
Assert.Equal(6, listener.Strings.Count);
Assert.True(listener.Strings[0].Contains("Query Opened: SELECT name FROM Test WHERE id=3"));
Assert.True(listener.Strings[1].Contains("Resultset Opened: field(s) = 1, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.True(listener.Strings[3].Contains("Usage Advisor Warning: The following columns were not accessed: name"));
Assert.True(listener.Strings[4].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=6"));
Assert.True(listener.Strings[5].Contains("Query Closed"));
}
public void NotReadingEveryRow()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test; SELECT * FROM Test WHERE id > 2", conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
reader.Read();
Assert.IsTrue(reader.NextResult());
reader.Read();
reader.Read();
Assert.IsFalse(reader.NextResult());
}
Assert.AreEqual(11, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test; SELECT * FROM Test WHERE id > 2"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[3].Contains("Usage Advisor Warning: Skipped 2 rows. Consider a more focused query."));
Assert.IsTrue(listener.Strings[4].Contains("Usage Advisor Warning: The following columns were not accessed: id,name"));
Assert.IsTrue(listener.Strings[5].Contains("Resultset Closed. Total rows=4, skipped rows=2, size (bytes)=32"));
Assert.IsTrue(listener.Strings[6].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[7].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[8].Contains("Usage Advisor Warning: The following columns were not accessed: id,name"));
Assert.IsTrue(listener.Strings[9].Contains("Resultset Closed. Total rows=2, skipped rows=0, size (bytes)=16"));
Assert.IsTrue(listener.Strings[10].Contains("Query Closed"));
}
public void SimpleLogging()
{
st.execSQL("INSERT INTO Test VALUES (1, 'Test1')");
st.execSQL("INSERT INTO Test VALUES (2, 'Test2')");
st.execSQL("INSERT INTO Test VALUES (3, 'Test3')");
st.execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
using (MySqlConnection logConn = new MySqlConnection(this.conn))
{
logConn.Open();
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test", logConn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
}
//Assert.Equal(4, listener.Strings.Count);
Assert.Equal(23, listener.Strings.Count);
Assert.True(listener.Strings[listener.Strings.Count - 5].Contains("Query Opened: SELECT * FROM Test"));
Assert.True(listener.Strings[listener.Strings.Count - 4].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[listener.Strings.Count - 3].Contains("Resultset Closed. Total rows=4, skipped rows=4, size (bytes)=32"));
Assert.True(listener.Strings[listener.Strings.Count - 2].Contains("Query Closed"));
}
public void ProcedureCache()
{
// open a new connection using a procedure cache
string connStr = Connection.ConnectionString;
connStr += ";procedure cache size=25;logging=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
// install our custom trace listener
GenericListener myListener = new GenericListener();
System.Diagnostics.Trace.Listeners.Add(myListener);
for (int x = 0; x < 10; x++)
{
ExecuteSQL("CREATE PROCEDURE spTest" + x + "() BEGIN SELECT 1; END");
MySqlCommand cmd = new MySqlCommand("spTest" + x, c);
cmd.CommandType = CommandType.StoredProcedure;
for (int y = 0; y < 20; y++)
{
cmd.ExecuteNonQuery();
}
}
// remove our custom trace listener
System.Diagnostics.Trace.Listeners.Remove(myListener);
// now see how many times our listener recorded a cache hit
Assert.AreEqual(190, myListener.Find("from procedure cache"));
Assert.AreEqual(10, myListener.Find("from server"));
}
}
public void ProviderNormalizingQuery()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
StringBuilder sql = new StringBuilder("SELECT '");
for (int i = 0; i < 400; i++)
{
sql.Append("a");
}
sql.Append("'");
using (MySqlConnection logConnection = new MySqlConnection(this.conn))
{
logConnection.Open();
MySqlCommand cmd = new MySqlCommand(sql.ToString(), logConnection);
cmd.ExecuteNonQuery();
}
Assert.Equal(24, listener.Strings.Count);
Assert.True(listener.Strings[listener.Strings.Count - 5].EndsWith("SELECT ?", StringComparison.OrdinalIgnoreCase));
}
public void FieldConversion()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test", conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
short s = reader.GetInt16(0);
long l = reader.GetInt64(0);
string str = reader.GetString(1);
}
Assert.AreEqual(6, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[3].Contains("Usage Advisor Warning: The field 'id' was converted to the following types: Int16,Int64"));
Assert.IsTrue(listener.Strings[4].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=8"));
Assert.IsTrue(listener.Strings[5].Contains("Query Closed"));
}
public void BadIndexUsed()
{
execSQL("DROP TABLE IF EXISTS Test");
execSQL("CREATE TABLE Test(id INT, name VARCHAR(20) PRIMARY KEY)");
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT name FROM Test WHERE id=3", conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
}
Assert.AreEqual(6, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: SELECT name FROM Test WHERE id=3"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 1, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[3].Contains("Usage Advisor Warning: The following columns were not accessed: name"));
Assert.IsTrue(listener.Strings[4].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=6"));
Assert.IsTrue(listener.Strings[5].Contains("Query Closed"));
}
public void SettingAgeOnCommand()
{
_fixture.execSQL("CREATE TABLE test2 (id INT, name VARCHAR(20), name2 VARCHAR(20))");
_fixture.execSQL("INSERT INTO test2 VALUES (1, 'boo', 'hoo'), (2, 'first', 'last'), (3, 'fred', 'flintstone')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = _fixture.GetConnectionString(true) + ";logging=true;table cache=true;default table cache age=1";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlCommand cmd = new MySqlCommand("test2", c);
cmd.CommandType = CommandType.TableDirect;
cmd.CacheAge = 20;
ConsumeReader(cmd);
Thread.Sleep(1000);
// now run the query again but this time it shouldn't generate a call to the database
// since we have overriden the connection string cache age of 1 second and set it
// to 20 seconds on our command
ConsumeReader(cmd);
}
Assert.Equal(1, listener.Find("Resultset Opened: field(s) = 3"));
}
public void Warnings()
{
ExecuteSQL("CREATE TABLE Test(id INT, name VARCHAR(5))");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
using (var logConn = new MySqlConnection(Connection.ConnectionString + ";logging=true"))
{
logConn.Open();
MySqlCommand cmd = new MySqlCommand("INSERT IGNORE INTO Test VALUES (1, 'abcdef')", logConn);
cmd.ExecuteNonQuery();
}
Assert.AreEqual(32, listener.Strings.Count);
StringAssert.Contains("Query Opened: INSERT IGNORE INTO Test VALUES (1, 'abcdef')", listener.Strings[listener.Strings.Count - 10]);
StringAssert.Contains("Resultset Opened: field(s) = 0, affected rows = 1, inserted id = 0", listener.Strings[listener.Strings.Count - 9]);
StringAssert.Contains("Resultset Closed. Total rows=0, skipped rows=0, size (bytes)=0", listener.Strings[listener.Strings.Count - 8]);
StringAssert.Contains("Query Opened: SHOW WARNINGS", listener.Strings[listener.Strings.Count - 7]);
StringAssert.Contains("Resultset Opened: field(s) = 3, affected rows = -1, inserted id = -1", listener.Strings[listener.Strings.Count - 6]);
StringAssert.Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=55", listener.Strings[listener.Strings.Count - 5]);
StringAssert.Contains("Query Closed", listener.Strings[listener.Strings.Count - 4]);
StringAssert.Contains("MySql Warning: Level=Warning, Code=1265, Message=Data truncated for column 'name' at row 1", listener.Strings[listener.Strings.Count - 3]);
StringAssert.Contains("Query Closed", listener.Strings[listener.Strings.Count - 2]);
}
public void QuotedTokenAt300()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string sql = @"SELECT 1 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1`, 2 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2`,
3 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3`, 4 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4`,
5 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5`, 6 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6`;";
MySqlCommand cmd = new MySqlCommand(sql, conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
}
public void UseOldSyntaxGivesWarning()
{
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
string connStr = conn.ConnectionString + ";old syntax=yes;pooling=false";
MySqlConnection conn2 = new MySqlConnection(connStr);
conn2.Open();
Assert.IsTrue(listener.Find("Use Old Syntax is now obsolete") != 0);
conn2.Close();
Trace.Listeners.Clear();
}
public void QuotedTokenAt300()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string sql = @"SELECT 1 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1`, 2 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2`,
3 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3`, 4 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4`,
5 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5`, 6 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6`;";
MySqlCommand cmd = new MySqlCommand(sql, conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
}
public void ProviderNormalizingQuery()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
StringBuilder sql = new StringBuilder("SELECT '");
for (int i = 0; i < 400; i++)
sql.Append("a");
sql.Append("'");
MySqlCommand cmd = new MySqlCommand(sql.ToString(), conn);
cmd.ExecuteNonQuery();
Assert.AreEqual(5, listener.Strings.Count);
Assert.IsTrue(listener.Strings[1].EndsWith("SELECT ?", StringComparison.OrdinalIgnoreCase));
}
public void NotReadingEveryRow()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test; SELECT * FROM Test WHERE id > 2", conn);
MySqlDataReader reader = null;
try
{
reader = cmd.ExecuteReader();
reader.Read();
reader.Read();
listener.Clear();
Assert.IsTrue(reader.NextResult());
Assert.IsTrue(listener.Find("Reason: Not all rows in resultset were read.") > 0);
reader.Read();
reader.Read();
listener.Clear();
Assert.IsFalse(reader.NextResult());
Assert.IsTrue(listener.Find("Reason: Not all rows in resultset were read.") > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
public void NotReadingEveryField()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test; SELECT * FROM Test WHERE id > 2", conn);
MySqlDataReader reader = null;
try
{
reader = cmd.ExecuteReader();
reader.Read();
reader.GetInt32(0); // access the first field
reader.Read();
Assert.IsTrue(reader.NextResult());
Assert.IsTrue(listener.Find("Fields not accessed: name") != 0);
reader.Read();
listener.Clear();
Assert.AreEqual("Test3", reader.GetString(1));
Assert.IsFalse(reader.NextResult());
Assert.IsTrue(listener.Find("Fields not accessed: id") > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
public void NotReadingEveryField()
{
executeSQL("CREATE TABLE Test (id int, name VARCHAR(200))");
executeSQL("INSERT INTO Test VALUES (1, 'Test1')");
executeSQL("INSERT INTO Test VALUES (2, 'Test2')");
executeSQL("INSERT INTO Test VALUES (3, 'Test3')");
executeSQL("INSERT INTO Test VALUES (4, 'Test4')");
#if !NETCORE10
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
#endif
string sql = "SELECT * FROM Test; SELECT * FROM Test WHERE id > 2";
MySqlCommand cmd = new MySqlCommand(sql, Connection);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
reader.GetInt32(0); // access the first field
reader.Read();
Assert.True(reader.NextResult());
reader.Read();
Assert.Equal("Test3", reader.GetString(1));
Assert.False(reader.NextResult());
}
#if !NETCORE10
Assert.Equal(12, listener.Strings.Count);
Assert.True(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test; SELECT * FROM Test WHERE id > 2"));
Assert.True(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.True(listener.Strings[3].Contains("Usage Advisor Warning: Skipped 2 rows. Consider a more focused query."));
Assert.True(listener.Strings[4].Contains("Usage Advisor Warning: The following columns were not accessed: name"));
Assert.True(listener.Strings[5].Contains("Resultset Closed. Total rows=4, skipped rows=2, size (bytes)=32"));
Assert.True(listener.Strings[6].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.True(listener.Strings[7].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.True(listener.Strings[8].Contains("Usage Advisor Warning: Skipped 1 rows. Consider a more focused query."));
Assert.True(listener.Strings[9].Contains("Usage Advisor Warning: The following columns were not accessed: id"));
Assert.True(listener.Strings[10].Contains("Resultset Closed. Total rows=2, skipped rows=1, size (bytes)=16"));
Assert.True(listener.Strings[11].Contains("Query Closed"));
#endif
}
public void QuotedTokenAt300()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string sql = @"SELECT 1 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1`, 2 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2`,
3 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3`, 4 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4`,
5 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5`, 6 AS `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6`;";
using (var logConn = new MySqlConnection(Connection.ConnectionString + ";logging=true"))
{
logConn.Open();
MySqlCommand cmd = new MySqlCommand(sql, logConn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
}
}
public void NotReadingEveryField()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test; SELECT * FROM Test WHERE id > 2", conn);
MySqlDataReader reader = null;
try
{
reader = cmd.ExecuteReader();
reader.Read();
reader.GetInt32(0); // access the first field
reader.Read();
Assert.IsTrue(reader.NextResult());
Assert.IsTrue(listener.Find("Fields not accessed: name") != 0);
reader.Read();
listener.Clear();
Assert.AreEqual("Test3", reader.GetString(1));
Assert.IsFalse(reader.NextResult());
Assert.IsTrue(listener.Find("Fields not accessed: id") > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
if (reader != null) reader.Close();
}
}
public void ProviderNormalizingQuery()
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
StringBuilder sql = new StringBuilder("SELECT '");
for (int i = 0; i < 400; i++)
{
sql.Append("a");
}
sql.Append("'");
MySqlCommand cmd = new MySqlCommand(sql.ToString(), conn);
cmd.ExecuteNonQuery();
Assert.AreEqual(5, listener.Strings.Count);
Assert.IsTrue(listener.Strings[1].EndsWith("SELECT ?"));
}
public void NotReadingEveryField()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string sql = "SELECT * FROM Test; SELECT * FROM Test WHERE id > 2";
MySqlCommand cmd = new MySqlCommand(sql, conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
reader.Read();
reader.GetInt32(0); // access the first field
reader.Read();
Assert.IsTrue(reader.NextResult());
reader.Read();
Assert.AreEqual("Test3", reader.GetString(1));
Assert.IsFalse(reader.NextResult());
}
Assert.AreEqual(12, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test; SELECT * FROM Test WHERE id > 2"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[2].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[3].Contains("Usage Advisor Warning: Skipped 2 rows. Consider a more focused query."));
Assert.IsTrue(listener.Strings[4].Contains("Usage Advisor Warning: The following columns were not accessed: name"));
Assert.IsTrue(listener.Strings[5].Contains("Resultset Closed. Total rows=4, skipped rows=2, size (bytes)=32"));
Assert.IsTrue(listener.Strings[6].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[7].Contains("Usage Advisor Warning: Query does not use an index"));
Assert.IsTrue(listener.Strings[8].Contains("Usage Advisor Warning: Skipped 1 rows. Consider a more focused query."));
Assert.IsTrue(listener.Strings[9].Contains("Usage Advisor Warning: The following columns were not accessed: id"));
Assert.IsTrue(listener.Strings[10].Contains("Resultset Closed. Total rows=2, skipped rows=1, size (bytes)=16"));
Assert.IsTrue(listener.Strings[11].Contains("Query Closed"));
}
public void SimpleLogging()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test", conn);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
}
Assert.AreEqual(4, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: SELECT * FROM Test"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[2].Contains("Resultset Closed. Total rows=4, skipped rows=4, size (bytes)=32"));
Assert.IsTrue(listener.Strings[3].Contains("Query Closed"));
}
public void UpdateSimple()
{
using (testEntities context = new testEntities())
{
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
Product pc = null;
try
{
pc = new Product();
pc.Name= "Acme";
context.AddToProducts(pc);
context.SaveChanges();
pc.Name = "Acme 2";
context.SaveChanges();
}
finally
{
#if CLR4
context.Products.DeleteObject(pc);
#endif
}
// Check sql
Regex rx = new Regex(@"Query Opened: (?<item>UPDATE .*)", RegexOptions.Compiled | RegexOptions.Singleline);
foreach( string s in listener.Strings )
{
Match m = rx.Match(s);
if (m.Success)
{
CheckSql(m.Groups["item"].Value, SQLSyntax.UpdateWithSelect);
Assert.Pass();
}
}
Assert.Fail();
}
}
public void Warnings()
{
execSQL("DROP TABLE IF EXISTS Test");
execSQL("CREATE TABLE Test(id INT, name VARCHAR(5))");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("INSERT IGNORE INTO Test VALUES (1, 'abcdef')", conn);
cmd.ExecuteNonQuery();
Assert.AreEqual(9, listener.Strings.Count);
Assert.IsTrue(listener.Strings[0].Contains("Query Opened: INSERT IGNORE INTO Test VALUES (1, 'abcdef')"));
Assert.IsTrue(listener.Strings[1].Contains("Resultset Opened: field(s) = 0, affected rows = 1, inserted id = 0"));
Assert.IsTrue(listener.Strings[2].Contains("Resultset Closed. Total rows=0, skipped rows=0, size (bytes)=0"));
Assert.IsTrue(listener.Strings[3].Contains("Query Opened: SHOW WARNINGS"));
Assert.IsTrue(listener.Strings[4].Contains("Resultset Opened: field(s) = 3, affected rows = -1, inserted id = -1"));
Assert.IsTrue(listener.Strings[5].Contains("Resultset Closed. Total rows=1, skipped rows=0, size (bytes)=55"));
Assert.IsTrue(listener.Strings[6].Contains("Query Closed"));
Assert.IsTrue(listener.Strings[7].Contains("MySql Warning: Level=Warning, Code=1265, Message=Data truncated for column 'name' at row 1"));
Assert.IsTrue(listener.Strings[8].Contains("Query Closed"));
}
private void CacheServerPropertiesInternal(bool cache)
{
string connStr = ConnectionSettings.ConnectionString +
String.Format(";logging=true;cache server properties={0}", cache);
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlTrace.Switch.Level = System.Diagnostics.SourceLevels.All;
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
using (MySqlConnection c2 = new MySqlConnection(connStr))
{
c2.Open();
KillConnection(c2);
}
KillConnection(c);
}
int count = listener.CountLinesContaining("SHOW VARIABLES");
Assert.Equal(cache ? 1 : 2, count);
}
public void SimpleTableCaching()
{
execSQL("CREATE TABLE test (id INT, name VARCHAR(20), name2 VARCHAR(20))");
execSQL("INSERT INTO test VALUES (1, 'boo', 'hoo'), (2, 'first', 'last'), (3, 'fred', 'flintstone')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = GetConnectionString(true) + ";logging=true;table cache=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlCommand cmd = new MySqlCommand("test", c);
cmd.CommandType = CommandType.TableDirect;
ConsumeReader(cmd);
// now run the query again but this time it shouldn't generate a call to the database
ConsumeReader(cmd);
}
Assert.AreEqual(1, listener.Find("Resultset Opened: field(s) = 3"));
}
public void NotReadingEveryRow()
{
execSQL("INSERT INTO Test VALUES (1, 'Test1')");
execSQL("INSERT INTO Test VALUES (2, 'Test2')");
execSQL("INSERT INTO Test VALUES (3, 'Test3')");
execSQL("INSERT INTO Test VALUES (4, 'Test4')");
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
MySqlCommand cmd = new MySqlCommand("SELECT * FROM Test; SELECT * FROM Test WHERE id > 2", conn);
MySqlDataReader reader = null;
try
{
reader = cmd.ExecuteReader();
reader.Read();
reader.Read();
listener.Clear();
Assert.IsTrue(reader.NextResult());
Assert.IsTrue(listener.Find("Reason: Not all rows in resultset were read.") > 0);
reader.Read();
reader.Read();
listener.Clear();
Assert.IsFalse(reader.NextResult());
Assert.IsTrue(listener.Find("Reason: Not all rows in resultset were read.") > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
if (reader != null) reader.Close();
}
}
public void ProcedureCache()
{
if (Version < new Version(5, 0)) return;
// open a new connection using a procedure cache
string connStr = GetConnectionString(true);
connStr += ";procedure cache size=25;logging=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
// install our custom trace listener
GenericListener myListener = new GenericListener();
System.Diagnostics.Trace.Listeners.Add(myListener);
for (int x = 0; x < 10; x++)
{
execSQL("CREATE PROCEDURE spTest" + x + "() BEGIN SELECT 1; END");
MySqlCommand cmd = new MySqlCommand("spTest" + x, c);
cmd.CommandType = CommandType.StoredProcedure;
for (int y = 0; y < 20; y++)
{
cmd.ExecuteNonQuery();
}
}
// remove our custom trace listener
System.Diagnostics.Trace.Listeners.Remove(myListener);
// now see how many times our listener recorded a cache hit
Assert.AreEqual(190, myListener.Find("from procedure cache"));
Assert.AreEqual(10, myListener.Find("from server"));
}
}
public void MultipleThreads()
{
GenericListener myListener = new GenericListener();
ManualResetEvent ev = new ManualResetEvent(false);
ArrayList threads = new ArrayList();
System.Diagnostics.Trace.Listeners.Add(myListener);
for (int i = 0; i < 20; i++)
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(MultipleThreadsWorker);
Thread t = new Thread(ts);
threads.Add(t);
t.Start(ev);
}
// now let the threads go
ev.Set();
// wait for the threads to end
int x = 0;
while (x < threads.Count)
{
while ((threads[x] as Thread).IsAlive)
Thread.Sleep(50);
x++;
}
}
public void UseOldSyntaxGivesWarning()
{
Trace.Listeners.Clear();
GenericListener listener = new GenericListener();
Trace.Listeners.Add(listener);
string connStr = conn.ConnectionString + ";old syntax=yes;pooling=false";
MySqlConnection conn2 = new MySqlConnection(connStr);
conn2.Open();
Assert.IsTrue(listener.Find("Use Old Syntax is now obsolete") != 0);
conn2.Close();
Trace.Listeners.Clear();
}
public void BatchUpdatesAndDeletes()
{
execSQL("CREATE TABLE test (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(20))");
execSQL("INSERT INTO test VALUES (1, 'boo'), (2, 'boo'), (3, 'boo')");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
string connStr = GetConnectionString(true) + ";logging=true;allow batch=true";
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
MySqlDataAdapter da = new MySqlDataAdapter("SELECT * FROM test", c);
MySqlCommandBuilder cb = new MySqlCommandBuilder(da);
da.UpdateCommand = cb.GetUpdateCommand();
da.UpdateCommand.UpdatedRowSource = UpdateRowSource.None;
da.UpdateBatchSize = 100;
DataTable dt = new DataTable();
da.Fill(dt);
dt.Rows[0]["name"] = "boo2";
dt.Rows[1]["name"] = "boo2";
dt.Rows[2]["name"] = "boo2";
da.Update(dt);
}
Assert.AreEqual(1, listener.Find("Query Opened: UPDATE"));
}
private void CacheServerPropertiesInternal(bool cache)
{
string connStr = GetPoolingConnectionString() +
String.Format(";logging=true;cache server properties={0}", cache);
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
MySqlTrace.Switch.Level = System.Diagnostics.SourceLevels.All;
using (MySqlConnection c = new MySqlConnection(connStr))
{
c.Open();
using (MySqlConnection c2 = new MySqlConnection(connStr))
{
c2.Open();
KillConnection(c2);
}
KillConnection(c);
}
int count = listener.CountLinesContaining("SHOW VARIABLES");
Assert.AreEqual(cache ? 1 : 2, count);
}
public void ProcedureCache()
{
// open a new connection using a procedure cache
string connStr = GetConnectionString(true);
connStr += ";procedure cache size=25;logging=true";
MySqlConnection c = new MySqlConnection(connStr);
try
{
c.Open();
// install our custom trace listener
GenericListener myListener = new GenericListener();
System.Diagnostics.Trace.Listeners.Add(myListener);
for (int x = 0; x < 10; x++)
{
execSQL("DROP PROCEDURE IF EXISTS spTest" + x);
execSQL("CREATE PROCEDURE spTest" + x + "() BEGIN SELECT 1; END");
MySqlCommand cmd = new MySqlCommand("spTest" + x, c);
cmd.CommandType = CommandType.StoredProcedure;
for (int y = 0; y < 20; y++)
{
cmd.ExecuteNonQuery();
}
}
// remove our custom trace listener
System.Diagnostics.Trace.Listeners.Remove(myListener);
// now see how many times our listener recorded a cache hit
Assert.AreEqual(190, myListener.Find("from procedure cache"));
Assert.AreEqual(10, myListener.Find("from server"));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
if (c != null)
c.Close();
for (int x = 0; x < 10; x++)
execSQL("DROP PROCEDURE IF EXISTS spTest" + x);
}
}
public void ConcurrencyCheck()
{
using (MovieDBContext db = new MovieDBContext())
{
db.Database.ExecuteSqlCommand(
@"DROP TABLE IF EXISTS `test3`.`MovieReleases`");
db.Database.ExecuteSqlCommand(
@"CREATE TABLE `MovieReleases` (
`Id` int(11) NOT NULL,
`Name` varbinary(45) NOT NULL,
`Timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`Id`)
) ENGINE=InnoDB DEFAULT CHARSET=binary");
MySqlTrace.Listeners.Clear();
MySqlTrace.Switch.Level = SourceLevels.All;
GenericListener listener = new GenericListener();
MySqlTrace.Listeners.Add(listener);
try
{
MovieRelease mr = db.MovieReleases.Create();
mr.Id = 1;
mr.Name = "Commercial";
db.MovieReleases.Add(mr);
db.SaveChanges();
mr.Name = "Director's Cut";
db.SaveChanges();
}
finally
{
db.Database.ExecuteSqlCommand(@"DROP TABLE IF EXISTS `MovieReleases`");
}
// Check sql
Regex rx = new Regex(@"Query Opened: (?<item>UPDATE .*)", RegexOptions.Compiled | RegexOptions.Singleline);
foreach (string s in listener.Strings)
{
Match m = rx.Match(s);
if (m.Success)
{
CheckSql(m.Groups["item"].Value, SQLSyntax.UpdateWithSelect);
Assert.Pass();
}
}
Assert.Fail();
}
}