diff --git a/RepoDb.MySqlConnector/README.md b/RepoDb.MySqlConnector/README.md new file mode 100644 index 000000000..5aeddbe94 --- /dev/null +++ b/RepoDb.MySqlConnector/README.md @@ -0,0 +1,108 @@ +[![MySqlBuild](https://img.shields.io/appveyor/ci/mikependon/repodb-6adn4)](https://ci.appveyor.com/project/mikependon/repodb-6adn4) +[![Home](https://img.shields.io/badge/home-github-important)](https://github.com/mikependon/RepoDb) +[![Website](https://img.shields.io/badge/website-information-yellow)](http://repodb.net) +[![GetStarted](https://img.shields.io/badge/tutorial-getstarted-blueviolet)](http://repodb.net/tutorial/get-started-mysql) +[![MySqlVersion](https://img.shields.io/nuget/v/RepoDb.MySql)](https://www.nuget.org/packages/RepoDb.MySql) +[![MySqlUnitTests](https://img.shields.io/appveyor/tests/mikependon/repodb-t2hy7?label=unit%20tests)](https://ci.appveyor.com/project/mikependon/repodb-t2hy7/build/tests) +[![MySqlIntegrationTests](https://img.shields.io/appveyor/tests/mikependon/repodb-o4t48?label=integration%20tests)](https://ci.appveyor.com/project/mikependon/repodb-o4t48/build/tests) + +# RepoDb.MySql - a hybrid .NET ORM library for MySQL. + +RepoDb is an open-source .NET ORM that bridge the gaps between micro-ORMs and full-ORMs. It helps the developer to simplify the switch-over of when to use the BASIC and ADVANCE operations during the development. + +It is the best alternative ORM to both Dapper and EntityFramework. + +## Important Pages + +- [GitHub Home Page](https://github.com/mikependon/RepoDb) - to learn more about the core library. +- [Website](http://repodb.net) - docs, features, classes, references, releases and blogs. + +## Community engagements + +- [GitHub](https://github.com/mikependon/RepoDb/issues) - for any issues, requests and problems. +- [StackOverflow](https://stackoverflow.com/questions/tagged/repodb) - for any technical questions. +- [Twitter](https://twitter.com/search?q=%23repodb) - for the latest news. +- [Gitter Chat](https://gitter.im/RepoDb/community) - for direct and live Q&A. + +## Dependencies + +- [MySql.Data](https://www.nuget.org/packages/MySql.Data/) - the data provider used for MySql. +- [RepoDb](https://www.nuget.org/packages/RepoDb/) - the core library of RepoDb. + +## License + +[Apache-2.0](http://apache.org/licenses/LICENSE-2.0.html) - Copyright © 2019 - Michael Camara Pendon + +-------- + +## Installation + +At the Package Manager Console, write the command below. + +```csharp +> Install-Package RepoDb.MySql +``` + +Or, visit our [installation](http://repodb.net/tutorial/installation) page for more information. + +## Get Started + +First, the bootstrapper must be initialized. + +```csharp +RepoDb.MySqlBootstrap.Initialize(); +``` + +**Note:** The call must be done once. + +After the bootstrap initialization, any library operation can then be called. + +Or, visit the official [get-started](http://repodb.net/tutorial/get-started-mysql) page for MySQL. + +### Query + +```csharp +using (var connection = new MySqlConnection(ConnectionString)) +{ + var customer = connection.Query(c => c.Id == 10045); +} +``` + +### Insert + +```csharp +var customer = new Customer +{ + FirstName = "John", + LastName = "Doe", + IsActive = true +}; +using (var connection = new MySqlConnection(ConnectionString)) +{ + var id = connection.Insert(customer); +} +``` + +### Update + +```csharp +using (var connection = new MySqlConnection(ConnectionString)) +{ + var customer = connection.Query(10045); + customer.FirstName = "John"; + customer.LastUpdatedUtc = DateTime.UtcNow; + var affectedRows = connection.Update(customer); +} +``` + +### Delete + +```csharp +using (var connection = new MySqlConnection(ConnectionString)) +{ + var customer = connection.Query(10045); + var deletedCount = connection.Delete(customer); +} +``` + +To learn more, please visit our [reference implementations](https://github.com/mikependon/RepoDb/blob/master/RepoDb.Docs/Reference%20Implementations.md) page. diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/DbHelperTests.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/DbHelperTests.cs new file mode 100644 index 000000000..b06569990 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/DbHelperTests.cs @@ -0,0 +1,244 @@ +using System; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; + +namespace RepoDb.MySql.IntegrationTests +{ + [TestClass] + public class DbHelperTests + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region GetFields + + #region Sync + + [TestMethod] + public void TestDbHelperGetFields() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFields(connection, "CompleteTable", null); + + // Assert + using (var reader = connection.ExecuteReader(@"SELECT COLUMN_NAME AS ColumnName + FROM INFORMATION_SCHEMA.COLUMNS + WHERE + TABLE_NAME = @TableName + ORDER BY ORDINAL_POSITION;", new { TableName = "CompleteTable" })) + { + var fieldCount = 0; + + while (reader.Read()) + { + var name = reader.GetString(0); + var field = fields.FirstOrDefault(f => string.Equals(f.Name, name, StringComparison.OrdinalIgnoreCase)); + + // Assert + Assert.IsNotNull(field); + + fieldCount++; + } + + // Assert + Assert.AreEqual(fieldCount, fields.Count()); + } + } + } + + [TestMethod] + public void TestDbHelperGetFieldsPrimary() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFields(connection, "CompleteTable", null); + var primary = fields.FirstOrDefault(f => f.IsPrimary == true); + + // Assert + Assert.IsNotNull(primary); + Assert.AreEqual("Id", primary.Name); + } + } + + [TestMethod] + public void TestDbHelperGetFieldsIdentity() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFields(connection, "CompleteTable", null); + var primary = fields.FirstOrDefault(f => f.IsIdentity == true); + + // Assert + Assert.IsNotNull(primary); + Assert.AreEqual("Id", primary.Name); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestDbHelperGetFieldsAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFieldsAsync(connection, "CompleteTable", null).Result; + + // Assert + using (var reader = connection.ExecuteReader(@"SELECT COLUMN_NAME AS ColumnName + FROM INFORMATION_SCHEMA.COLUMNS + WHERE + TABLE_NAME = @TableName + ORDER BY ORDINAL_POSITION;", new { TableName = "CompleteTable" })) + { + var fieldCount = 0; + + while (reader.Read()) + { + var name = reader.GetString(0); + var field = fields.FirstOrDefault(f => string.Equals(f.Name, name, StringComparison.OrdinalIgnoreCase)); + + // Assert + Assert.IsNotNull(field); + + fieldCount++; + } + + // Assert + Assert.AreEqual(fieldCount, fields.Count()); + } + } + } + + [TestMethod] + public void TestDbHelperGetFieldsAsyncPrimary() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFieldsAsync(connection, "CompleteTable", null).Result; + var primary = fields.FirstOrDefault(f => f.IsPrimary == true); + + // Assert + Assert.IsNotNull(primary); + Assert.AreEqual("Id", primary.Name); + } + } + + [TestMethod] + public void TestDbHelperGetFieldsAsyncIdentity() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + + // Act + var fields = helper.GetFieldsAsync(connection, "CompleteTable", null).Result; + var primary = fields.FirstOrDefault(f => f.IsIdentity == true); + + // Assert + Assert.IsNotNull(primary); + Assert.AreEqual("Id", primary.Name); + } + } + + #endregion + + #endregion + + #region GetScopeIdentity + + #region Sync + + [TestMethod] + public void TestDbHelperGetScopeIdentity() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + var table = Helper.CreateCompleteTables(1).First(); + + // Act + var insertResult = connection.Insert(table); + + // Assert + Assert.IsTrue(Convert.ToInt64(insertResult) > 0); + Assert.IsTrue(table.Id > 0); + + // Act + var result = helper.GetScopeIdentity(connection, null); + + // Assert + Assert.AreEqual(insertResult, result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestDbHelperGetScopeIdentityAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var helper = connection.GetDbHelper(); + var table = Helper.CreateCompleteTables(1).First(); + + // Act + var insertResult = connection.Insert(table); + + // Assert + Assert.IsTrue(Convert.ToInt64(insertResult) > 0); + Assert.IsTrue(table.Id > 0); + + // Act + var result = helper.GetScopeIdentityAsync(connection, null).Result; + + // Assert + Assert.AreEqual(insertResult, result); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/EnumTests.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/EnumTests.cs new file mode 100644 index 000000000..29822a63b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/EnumTests.cs @@ -0,0 +1,277 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Attributes; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests +{ + [TestClass] + public class EnumTests + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Enumerations + + public enum Hands + { + Unidentified, + Left, + Right + } + + #endregion + + #region SubClasses + + [Map("CompleteTable")] + public class PersonWithText + { + public System.Int64 Id { get; set; } + public Hands? ColumnText { get; set; } + } + + [Map("CompleteTable")] + public class PersonWithInteger + { + public System.Int64 Id { get; set; } + public Hands? ColumnInt { get; set; } + } + + [Map("CompleteTable")] + public class PersonWithTextAsInteger + { + public System.Int64 Id { get; set; } + [TypeMap(System.Data.DbType.Int32)] + public Hands? ColumnText { get; set; } + } + + #endregion + + #region Helpers + + public IEnumerable GetPersonWithText(int count) + { + var random = new Random(); + for (var i = 0; i < count; i++) + { + var hand = random.Next(100) > 50 ? Hands.Right : Hands.Left; + yield return new PersonWithText + { + Id = i, + ColumnText = hand + }; + } + } + + public IEnumerable GetPersonWithInteger(int count) + { + var random = new Random(); + for (var i = 0; i < count; i++) + { + var hand = random.Next(100) > 50 ? Hands.Right : Hands.Left; + yield return new PersonWithInteger + { + Id = i, + ColumnInt = hand + }; + } + } + + public IEnumerable GetPersonWithTextAsInteger(int count) + { + var random = new Random(); + for (var i = 0; i < count; i++) + { + var hand = random.Next(100) > 50 ? Hands.Right : Hands.Left; + yield return new PersonWithTextAsInteger + { + Id = i, + ColumnText = hand + }; + } + } + + #endregion + + [TestMethod] + public void TestInsertAndQueryEnumAsTextAsNull() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var person = GetPersonWithText(1).First(); + person.ColumnText = null; + + // Act + connection.Insert(person); + + // Query + var queryResult = connection.Query(person.Id).First(); + + // Assert + Assert.IsNull(queryResult.ColumnText); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsText() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var person = GetPersonWithText(1).First(); + + // Act + connection.Insert(person); + + // Query + var queryResult = connection.Query(person.Id).First(); + + // Assert + Assert.AreEqual(person.ColumnText, queryResult.ColumnText); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsTextByBatch() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var people = GetPersonWithText(10).AsList(); + + // Act + connection.InsertAll(people); + + // Query + var queryResult = connection.QueryAll().AsList(); + + // Assert + people.ForEach(p => + { + var item = queryResult.First(e => e.Id == p.Id); + Assert.AreEqual(p.ColumnText, item.ColumnText); + }); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsIntegerAsNull() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var person = GetPersonWithInteger(1).First(); + person.ColumnInt = null; + + // Act + connection.Insert(person); + + // Query + var queryResult = connection.Query(person.Id).First(); + + // Assert + Assert.IsNull(queryResult.ColumnInt); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsInteger() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var person = GetPersonWithInteger(1).First(); + + // Act + connection.Insert(person); + + // Query + var queryResult = connection.Query(person.Id).First(); + + // Assert + Assert.AreEqual(person.ColumnInt, queryResult.ColumnInt); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsIntegerAsBatch() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var people = GetPersonWithInteger(10).AsList(); + + // Act + connection.InsertAll(people); + + // Query + var queryResult = connection.QueryAll().AsList(); + + // Assert + people.ForEach(p => + { + var item = queryResult.First(e => e.Id == p.Id); + Assert.AreEqual(p.ColumnInt, item.ColumnInt); + }); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsTextAsInt() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var person = GetPersonWithTextAsInteger(1).First(); + + // Act + connection.Insert(person); + + // Query + var queryResult = connection.Query(person.Id).First(); + + // Assert + Assert.AreEqual(person.ColumnText, queryResult.ColumnText); + } + } + + [TestMethod] + public void TestInsertAndQueryEnumAsTextAsIntAsBatch() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var people = GetPersonWithTextAsInteger(10).AsList(); + + // Act + connection.InsertAll(people); + + // Query + var queryResult = connection.QueryAll().AsList(); + + // Assert + people.ForEach(p => + { + var item = queryResult.First(e => e.Id == p.Id); + Assert.AreEqual(p.ColumnText, item.ColumnText); + }); + } + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Helper.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Helper.cs new file mode 100644 index 000000000..3af3b001b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Helper.cs @@ -0,0 +1,609 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using System; +using System.Collections.Generic; +using System.Dynamic; +using System.Linq; +using System.Text; + +namespace RepoDb.MySql.IntegrationTests +{ + public static class Helper + { + static Helper() + { + EpocDate = new DateTime(1970, 1, 1, 0, 0, 0); + } + + /// + /// Gets the value of the Epoc date. + /// + public static DateTime EpocDate { get; } + + /// + /// Gets the current object in used. + /// + public static Random Randomizer => new Random(1); + + /// + /// Asserts the properties equality of 2 types. + /// + /// The type of first object. + /// The type of second object. + /// The instance of first object. + /// The instance of second object. + public static void AssertPropertiesEquality(T1 t1, T2 t2) + { + var propertiesOfType1 = typeof(T1).GetProperties(); + var propertiesOfType2 = typeof(T2).GetProperties(); + propertiesOfType1.AsList().ForEach(propertyOfType1 => + { + if (propertyOfType1.Name == "Id") + { + return; + } + var propertyOfType2 = propertiesOfType2.FirstOrDefault(p => p.Name == propertyOfType1.Name); + if (propertyOfType2 == null) + { + return; + } + var value1 = propertyOfType1.GetValue(t1); + var value2 = propertyOfType2.GetValue(t2); + if (value1 is byte[] && value2 is byte[]) + { + var b1 = (byte[])value1; + var b2 = (byte[])value2; + for (var i = 0; i < Math.Min(b1.Length, b2.Length); i++) + { + var v1 = b1[i]; + var v2 = b2[i]; + Assert.AreEqual(v1, v2, + $"Assert failed for '{propertyOfType1.Name}'. The values are '{value1} ({propertyOfType1.PropertyType.FullName})' and '{value2} ({propertyOfType2.PropertyType.FullName})'."); + } + } + else + { + Assert.AreEqual(value1, value2, + $"Assert failed for '{propertyOfType1.Name}'. The values are '{value1} ({propertyOfType1.PropertyType.FullName})' and '{value2} ({propertyOfType2.PropertyType.FullName})'."); + } + }); + } + + /// + /// Asserts the members equality of 2 object and . + /// + /// The type of first object. + /// The instance of first object. + /// The instance of second object. + public static void AssertMembersEquality(object obj, object expandoObj) + { + var dictionary = new ExpandoObject() as IDictionary; + foreach (var property in expandoObj.GetType().GetProperties()) + { + dictionary.Add(property.Name, property.GetValue(expandoObj)); + } + AssertMembersEquality(obj, dictionary); + } + + /// + /// Asserts the members equality of 2 object and . + /// + /// The type of first object. + /// The instance of first object. + /// The instance of second object. + public static void AssertMembersEquality(object obj, ExpandoObject expandoObj) + { + var dictionary = expandoObj as IDictionary; + AssertMembersEquality(obj, dictionary); + } + + /// + /// Asserts the members equality of 2 objects. + /// + /// The type of first object. + /// The instance of first object. + /// The instance of second object. + public static void AssertMembersEquality(object obj, IDictionary dictionary) + { + var properties = obj.GetType().GetProperties(); + properties.AsList().ForEach(property => + { + if (property.Name == "Id") + { + return; + } + if (dictionary.ContainsKey(property.Name)) + { + var value1 = property.GetValue(obj); + var value2 = dictionary[property.Name]; + if (value1 is byte[] && value2 is byte[]) + { + var b1 = (byte[])value1; + var b2 = (byte[])value2; + for (var i = 0; i < Math.Min(b1.Length, b2.Length); i++) + { + var v1 = b1[i]; + var v2 = b2[i]; + Assert.AreEqual(v1, v2, + $"Assert failed for '{property.Name}'. The values are '{v1}' and '{v2}'."); + } + } + else + { + var propertyType = property.PropertyType.GetUnderlyingType(); + if (propertyType == typeof(TimeSpan) && value2 is DateTime) + { + value2 = ((DateTime)value2).TimeOfDay; + } + Assert.AreEqual(Convert.ChangeType(value1, propertyType), Convert.ChangeType(value2, propertyType), + $"Assert failed for '{property.Name}'. The values are '{value1}' and '{value2}'."); + } + } + }); + } + + #region CompleteTable + + /// + /// Creates a list of objects. + /// + /// The number of rows. + /// A list of objects. + public static List CreateCompleteTables(int count) + { + var tables = new List(); + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + for (var i = 0; i < count; i++) + { + tables.Add(new CompleteTable + { + ColumnVarchar = $"ColumnVarChar:{i}", + ColumnInt = i, + ColumnDecimal2 = Convert.ToDecimal(i), + ColumnDateTime = EpocDate, + ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{i}"), + ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{i}"), + ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{i}"), + ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{i}"), + ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{i}"), + ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{i}"), + ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{i}"), + ColumnDate = EpocDate, + ColumnDateTime2 = now, + ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay, + ColumnTimeStamp = now, + ColumnYear = Convert.ToInt16(now.Year), + //ColumnGeometry = Encoding.Default.GetBytes($"POLYGON ((0 0, 50 0, 50 50, 0 50, 0 0))"), + //ColumnLineString = Encoding.Default.GetBytes($"LINESTRING (-122.36 47.656, -122.343 47.656)"), + //ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{i}"), + //ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{i}"), + //ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{i}"), + //ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{i}"), + //ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{i}"), + ColumnBigint = i, + ColumnDecimal = Convert.ToDecimal(i), + ColumnDouble = Convert.ToDouble(i), + ColumnFloat = Convert.ToSingle(i), + ColumnInt2 = i, + ColumnMediumInt = i, + ColumnReal = Convert.ToDouble(i), + ColumnSmallInt = Convert.ToInt16(i), + ColumnTinyInt = (SByte)i, + ColumnChar = "C", + ColumnJson = "{\"Field1\": \"Value1\", \"Field2\": \"Value2\"}", + ColumnNChar = "C", + ColumnNVarChar = $"ColumnNVarChar:{i}", + ColumnLongText = $"ColumnLongText:{i}", + ColumnMediumText = $"ColumnMediumText:{i}", + ColumnText = $"ColumText:{i}", + ColumnTinyText = $"ColumnTinyText:{i}", + ColumnBit = 1 + }); + } + return tables; + } + + /// + /// Update the properties of instance. + /// + /// The instance to be updated. + public static void UpdateCompleteTableProperties(CompleteTable table) + { + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + table.ColumnVarchar = $"ColumnVarChar:{1}-Updated"; + table.ColumnInt = 1; + table.ColumnDecimal2 = Convert.ToDecimal(1); + table.ColumnDateTime = EpocDate; + table.ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{1}-Updated"); + table.ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{1}-Updated"); + table.ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{1}-Updated"); + table.ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{1}-Updated"); + table.ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{1}-Updated"); + table.ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{1}-Updated"); + table.ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{1}-Updated"); + table.ColumnDate = EpocDate; + table.ColumnDateTime2 = now; + table.ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay; + table.ColumnTimeStamp = now; + table.ColumnYear = Convert.ToInt16(now.Year); + //table.ColumnGeometry = Encoding.Default.GetBytes($"ColumnGeometry:{1}"); + //table.ColumnLineString = Encoding.Default.GetBytes($"ColumnLineString:{1}"); + //table.ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{1}"); + //table.ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{1}"); + //table.ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{1}"); + //table.ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{1}"); + //table.ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{1}"); + table.ColumnBigint = 1; + table.ColumnDecimal = Convert.ToDecimal(1); + table.ColumnDouble = Convert.ToDouble(1); + table.ColumnFloat = Convert.ToSingle(1); + table.ColumnInt2 = 1; + table.ColumnMediumInt = 1; + table.ColumnReal = Convert.ToDouble(1); + table.ColumnSmallInt = Convert.ToInt16(1); + table.ColumnTinyInt = (SByte)1; + table.ColumnChar = "C"; + table.ColumnJson = "{\"Field\": \"Value-Updated\"}"; + table.ColumnNChar = "C"; + table.ColumnNVarChar = $"ColumnNVarChar:{1}-Updated"; + table.ColumnLongText = $"ColumnLongText:{1}-Updated"; + table.ColumnMediumText = $"ColumnMediumText:{1}-Updated"; + table.ColumnText = $"ColumText:{1}-Updated"; + table.ColumnTinyText = $"ColumnTinyText:{1}-Updated"; + table.ColumnBit = (UInt64)1; + } + + /// + /// Creates a list of objects represented as dynamics. + /// + /// The number of rows. + /// A list of objects represented as dynamics. + public static List CreateCompleteTablesAsDynamics(int count) + { + var tables = new List(); + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + for (var i = 0; i < count; i++) + { + tables.Add(new + { + Id = (long)(i + 1), + ColumnVarchar = $"ColumnVarChar:{i}", + ColumnInt = i, + ColumnDecimal2 = Convert.ToDecimal(i), + ColumnDateTime = EpocDate, + ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{i}"), + ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{i}"), + ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{i}"), + ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{i}"), + ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{i}"), + ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{i}"), + ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{i}"), + ColumnDate = EpocDate, + ColumnDateTime2 = now, + ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay, + ColumnTimeStamp = now, + ColumnYear = Convert.ToInt16(now.Year), + //ColumnGeometry = Encoding.Default.GetBytes($"POLYGON ((0 0, 50 0, 50 50, 0 50, 0 0))"), + //ColumnLineString = Encoding.Default.GetBytes($"LINESTRING (-122.36 47.656, -122.343 47.656)"), + //ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{i}"), + //ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{i}"), + //ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{i}"), + //ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{i}"), + //ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{i}"), + ColumnBigint = i, + ColumnDecimal = Convert.ToDecimal(i), + ColumnDouble = Convert.ToDouble(i), + ColumnFloat = Convert.ToSingle(i), + ColumnInt2 = i, + ColumnMediumInt = i, + ColumnReal = Convert.ToDouble(i), + ColumnSmallInt = Convert.ToInt16(i), + ColumnTinyInt = (SByte)i, + ColumnChar = "C", + ColumnJson = "{\"Field1\": \"Value1\", \"Field2\": \"Value2\"}", + ColumnNChar = "C", + ColumnNVarChar = $"ColumnNVarChar:{i}", + ColumnLongText = $"ColumnLongText:{i}", + ColumnMediumText = $"ColumnMediumText:{i}", + ColumnText = $"ColumText:{i}", + ColumnTinyText = $"ColumnTinyText:{i}", + ColumnBit = 1 + }); + } + return tables; + } + + /// + /// Update the properties of instance represented asy dynamic. + /// + /// The instance to be updated. + public static void UpdateCompleteTableAsDynamicProperties(dynamic table) + { + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + table.ColumnVarchar = $"ColumnVarChar:{1}"; + table.ColumnInt = 1; + table.ColumnDecimal2 = Convert.ToDecimal(1); + table.ColumnDateTime = EpocDate; + table.ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{1}"); + table.ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{1}"); + table.ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{1}"); + table.ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{1}"); + table.ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{1}"); + table.ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{1}"); + table.ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{1}"); + table.ColumnDate = EpocDate; + table.ColumnDateTime2 = now; + table.ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay; + table.ColumnTimeStamp = now; + table.ColumnYear = Convert.ToInt16(now.Year); + //table.ColumnGeometry = Encoding.Default.GetBytes($"ColumnGeometry:{1}"); + //table.ColumnLineString = Encoding.Default.GetBytes($"ColumnLineString:{1}"); + //table.ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{1}"); + //table.ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{1}"); + //table.ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{1}"); + //table.ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{1}"); + //table.ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{1}"); + table.ColumnBigint = 1; + table.ColumnDecimal = Convert.ToDecimal(1); + table.ColumnDouble = Convert.ToDouble(1); + table.ColumnFloat = Convert.ToSingle(1); + table.ColumnInt2 = 1; + table.ColumnMediumInt = 1; + table.ColumnReal = Convert.ToDouble(1); + table.ColumnSmallInt = Convert.ToInt16(1); + table.ColumnTinyInt = (SByte)1; + table.ColumnChar = "C"; + table.ColumnJson = "{ \"Field\" : \"Value\" }"; + table.ColumnNChar = "C"; + table.ColumnNVarChar = $"ColumnNVarChar:{1}"; + table.ColumnLongText = $"ColumnLongText:{1}"; + table.ColumnMediumText = $"ColumnMediumText:{1}"; + table.ColumnText = $"ColumText:{1}"; + table.ColumnTinyText = $"ColumnTinyText:{1}"; + table.ColumnBit = (UInt64)1; + } + + #endregion + + #region NonIdentityCompleteTable + + /// + /// Creates a list of objects. + /// + /// The number of rows. + /// A list of objects. + public static List CreateNonIdentityCompleteTables(int count) + { + var tables = new List(); + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + for (var i = 0; i < count; i++) + { + tables.Add(new NonIdentityCompleteTable + { + Id = (i + 1), + ColumnVarchar = $"ColumnVarChar:{i}", + ColumnInt = i, + ColumnDecimal2 = Convert.ToDecimal(i), + ColumnDateTime = EpocDate, + ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{i}"), + ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{i}"), + ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{i}"), + ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{i}"), + ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{i}"), + ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{i}"), + ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{i}"), + ColumnDate = EpocDate, + ColumnDateTime2 = now, + ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay, + ColumnTimeStamp = now, + ColumnYear = Convert.ToInt16(now.Year), + //ColumnGeometry = Encoding.Default.GetBytes($"POLYGON ((0 0, 50 0, 50 50, 0 50, 0 0))"), + //ColumnLineString = Encoding.Default.GetBytes($"LINESTRING (-122.36 47.656, -122.343 47.656)"), + //ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{i}"), + //ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{i}"), + //ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{i}"), + //ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{i}"), + //ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{i}"), + ColumnBigint = i, + ColumnDecimal = Convert.ToDecimal(i), + ColumnDouble = Convert.ToDouble(i), + ColumnFloat = Convert.ToSingle(i), + ColumnInt2 = i, + ColumnMediumInt = i, + ColumnReal = Convert.ToDouble(i), + ColumnSmallInt = Convert.ToInt16(i), + ColumnTinyInt = (SByte)i, + ColumnChar = "C", + ColumnJson = "{\"Field1\": \"Value1\", \"Field2\": \"Value2\"}", + ColumnNChar = "C", + ColumnNVarChar = $"ColumnNVarChar:{i}", + ColumnLongText = $"ColumnLongText:{i}", + ColumnMediumText = $"ColumnMediumText:{i}", + ColumnText = $"ColumText:{i}", + ColumnTinyText = $"ColumnTinyText:{i}", + ColumnBit = 1 + }); + } + return tables; + } + + /// + /// Update the properties of instance. + /// + /// The instance to be updated. + public static void UpdateNonIdentityCompleteTableProperties(NonIdentityCompleteTable table) + { + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + table.ColumnVarchar = $"ColumnVarChar:{1}"; + table.ColumnInt = 1; + table.ColumnDecimal2 = Convert.ToDecimal(1); + table.ColumnDateTime = EpocDate; + table.ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{1}"); + table.ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{1}"); + table.ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{1}"); + table.ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{1}"); + table.ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{1}"); + table.ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{1}"); + table.ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{1}"); + table.ColumnDate = EpocDate; + table.ColumnDateTime2 = now; + table.ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay; + table.ColumnTimeStamp = now; + table.ColumnYear = Convert.ToInt16(now.Year); + //table.ColumnGeometry = Encoding.Default.GetBytes($"ColumnGeometry:{1}"); + //table.ColumnLineString = Encoding.Default.GetBytes($"ColumnLineString:{1}"); + //table.ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{1}"); + //table.ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{1}"); + //table.ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{1}"); + //table.ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{1}"); + //table.ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{1}"); + table.ColumnBigint = 1; + table.ColumnDecimal = Convert.ToDecimal(1); + table.ColumnDouble = Convert.ToDouble(1); + table.ColumnFloat = Convert.ToSingle(1); + table.ColumnInt2 = 1; + table.ColumnMediumInt = 1; + table.ColumnReal = Convert.ToDouble(1); + table.ColumnSmallInt = Convert.ToInt16(1); + table.ColumnTinyInt = (SByte)1; + table.ColumnChar = "C"; + table.ColumnJson = "{\"Field\": \"Value\"}"; + table.ColumnNChar = "C"; + table.ColumnNVarChar = $"ColumnNVarChar:{1}"; + table.ColumnLongText = $"ColumnLongText:{1}"; + table.ColumnMediumText = $"ColumnMediumText:{1}"; + table.ColumnText = $"ColumText:{1}"; + table.ColumnTinyText = $"ColumnTinyText:{1}"; + table.ColumnBit = (UInt64)1; + } + + /// + /// Creates a list of objects represented as dynamics. + /// + /// The number of rows. + /// A list of objects represented as dynamics. + public static List CreateNonIdentityCompleteTablesAsDynamics(int count) + { + var tables = new List(); + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + for (var i = 0; i < count; i++) + { + tables.Add(new + { + Id = (long)(i + 1), + ColumnVarchar = $"ColumnVarChar:{i}", + ColumnInt = i, + ColumnDecimal2 = Convert.ToDecimal(i), + ColumnDateTime = EpocDate, + ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{i}"), + ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{i}"), + ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{i}"), + ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{i}"), + ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{i}"), + ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{i}"), + ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{i}"), + ColumnDate = EpocDate, + ColumnDateTime2 = now, + ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay, + ColumnTimeStamp = now, + ColumnYear = Convert.ToInt16(now.Year), + //ColumnGeometry = Encoding.Default.GetBytes($"POLYGON ((0 0, 50 0, 50 50, 0 50, 0 0))"), + //ColumnLineString = Encoding.Default.GetBytes($"LINESTRING (-122.36 47.656, -122.343 47.656)"), + //ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{i}"), + //ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{i}"), + //ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{i}"), + //ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{i}"), + //ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{i}"), + ColumnBigint = i, + ColumnDecimal = Convert.ToDecimal(i), + ColumnDouble = Convert.ToDouble(i), + ColumnFloat = Convert.ToSingle(i), + ColumnInt2 = i, + ColumnMediumInt = i, + ColumnReal = Convert.ToDouble(i), + ColumnSmallInt = Convert.ToInt16(i), + ColumnTinyInt = (SByte)i, + ColumnChar = "C", + ColumnJson = "{\"Field1\": \"Value1\", \"Field2\": \"Value2\"}", + ColumnNChar = "C", + ColumnNVarChar = $"ColumnNVarChar:{i}", + ColumnLongText = $"ColumnLongText:{i}", + ColumnMediumText = $"ColumnMediumText:{i}", + ColumnText = $"ColumText:{i}", + ColumnTinyText = $"ColumnTinyText:{i}", + ColumnBit = 1 + }); + } + return tables; + } + + /// + /// Update the properties of instance represented asy dynamic. + /// + /// The instance to be updated. + public static void UpdateNonIdentityCompleteTableAsDynamicProperties(dynamic table) + { + var now = DateTime.SpecifyKind( + DateTime.Parse(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fffff")), + DateTimeKind.Unspecified); + table.ColumnVarchar = $"ColumnVarChar:{1}"; + table.ColumnInt = 1; + table.ColumnDecimal2 = Convert.ToDecimal(1); + table.ColumnDateTime = EpocDate; + table.ColumnBlob = Encoding.Default.GetBytes($"ColumnBlob:{1}"); + table.ColumnBlobAsArray = Encoding.Default.GetBytes($"ColumnBlobAsArray:{1}"); + table.ColumnBinary = Encoding.Default.GetBytes($"ColumnBinary:{1}"); + table.ColumnLongBlob = Encoding.Default.GetBytes($"ColumnLongBlob:{1}"); + table.ColumnMediumBlob = Encoding.Default.GetBytes($"ColumnMediumBlob:{1}"); + table.ColumnTinyBlob = Encoding.Default.GetBytes($"ColumnTinyBlob:{1}"); + table.ColumnVarBinary = Encoding.Default.GetBytes($"ColumnVarBinary:{1}"); + table.ColumnDate = EpocDate; + table.ColumnDateTime2 = now; + table.ColumnTime = EpocDate.AddHours(5).AddMinutes(7).AddSeconds(12).TimeOfDay; + table.ColumnTimeStamp = now; + table.ColumnYear = Convert.ToInt16(now.Year); + //table.ColumnGeometry = Encoding.Default.GetBytes($"ColumnGeometry:{1}"); + //table.ColumnLineString = Encoding.Default.GetBytes($"ColumnLineString:{1}"); + //table.ColumnMultiLineString = Encoding.Default.GetBytes($"ColumnMultiLineString:{1}"); + //table.ColumnMultiPoint = Encoding.Default.GetBytes($"ColumnMultiPoint:{1}"); + //table.ColumnMultiPolygon = Encoding.Default.GetBytes($"ColumnMultiPolygon:{1}"); + //table.ColumnPoint = Encoding.Default.GetBytes($"ColumnPoint:{1}"); + //table.ColumnPolygon = Encoding.Default.GetBytes($"ColumnPolygon:{1}"); + table.ColumnBigint = 1; + table.ColumnDecimal = Convert.ToDecimal(1); + table.ColumnDouble = Convert.ToDouble(1); + table.ColumnFloat = Convert.ToSingle(1); + table.ColumnInt2 = 1; + table.ColumnMediumInt = 1; + table.ColumnReal = Convert.ToDouble(1); + table.ColumnSmallInt = Convert.ToInt16(1); + table.ColumnTinyInt = (SByte)1; + table.ColumnChar = "C"; + table.ColumnJson = "{ \"Field\" : \"Value\" }"; + table.ColumnNChar = "C"; + table.ColumnNVarChar = $"ColumnNVarChar:{1}"; + table.ColumnLongText = $"ColumnLongText:{1}"; + table.ColumnMediumText = $"ColumnMediumText:{1}"; + table.ColumnText = $"ColumText:{1}"; + table.ColumnTinyText = $"ColumnTinyText:{1}"; + table.ColumnBit = (UInt64)1; + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/CompleteTable.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/CompleteTable.cs new file mode 100644 index 000000000..4c69c4041 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/CompleteTable.cs @@ -0,0 +1,50 @@ +using System; + +namespace RepoDb.MySql.IntegrationTests.Models +{ + public class CompleteTable + { + public Int64? Id { get; set; } + public String ColumnVarchar { get; set; } + public Int32? ColumnInt { get; set; } + public Decimal? ColumnDecimal2 { get; set; } + public DateTime? ColumnDateTime { get; set; } + public Byte[] ColumnBlob { get; set; } + public Byte[] ColumnBlobAsArray { get; set; } + public Byte[] ColumnBinary { get; set; } + public Byte[] ColumnLongBlob { get; set; } + public Byte[] ColumnMediumBlob { get; set; } + public Byte[] ColumnTinyBlob { get; set; } + public Byte[] ColumnVarBinary { get; set; } + public DateTime? ColumnDate { get; set; } + public DateTime? ColumnDateTime2 { get; set; } + public TimeSpan? ColumnTime { get; set; } + public DateTime? ColumnTimeStamp { get; set; } + public Int16? ColumnYear { get; set; } + public Byte[] ColumnGeometry { get; set; } + public Byte[] ColumnLineString { get; set; } + public Byte[] ColumnMultiLineString { get; set; } + public Byte[] ColumnMultiPoint { get; set; } + public Byte[] ColumnMultiPolygon { get; set; } + public Byte[] ColumnPoint { get; set; } + public Byte[] ColumnPolygon { get; set; } + public Int64? ColumnBigint { get; set; } + public Decimal? ColumnDecimal { get; set; } + public Double? ColumnDouble { get; set; } + public Single? ColumnFloat { get; set; } + public Int32? ColumnInt2 { get; set; } + public Int32? ColumnMediumInt { get; set; } + public Double? ColumnReal { get; set; } + public Int16? ColumnSmallInt { get; set; } + public SByte? ColumnTinyInt { get; set; } + public String ColumnChar { get; set; } + public String ColumnJson { get; set; } + public String ColumnNChar { get; set; } + public String ColumnNVarChar { get; set; } + public String ColumnLongText { get; set; } + public String ColumnMediumText { get; set; } + public String ColumnText { get; set; } + public String ColumnTinyText { get; set; } + public UInt64? ColumnBit { get; set; } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/NonIdentityCompleteTable.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/NonIdentityCompleteTable.cs new file mode 100644 index 000000000..f4afa4f02 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Models/NonIdentityCompleteTable.cs @@ -0,0 +1,50 @@ +using System; + +namespace RepoDb.MySql.IntegrationTests.Models +{ + public class NonIdentityCompleteTable + { + public Int64? Id { get; set; } + public String ColumnVarchar { get; set; } + public Int32? ColumnInt { get; set; } + public Decimal? ColumnDecimal2 { get; set; } + public DateTime? ColumnDateTime { get; set; } + public Byte[] ColumnBlob { get; set; } + public Byte[] ColumnBlobAsArray { get; set; } + public Byte[] ColumnBinary { get; set; } + public Byte[] ColumnLongBlob { get; set; } + public Byte[] ColumnMediumBlob { get; set; } + public Byte[] ColumnTinyBlob { get; set; } + public Byte[] ColumnVarBinary { get; set; } + public DateTime? ColumnDate { get; set; } + public DateTime? ColumnDateTime2 { get; set; } + public TimeSpan? ColumnTime { get; set; } + public DateTime? ColumnTimeStamp { get; set; } + public Int16? ColumnYear { get; set; } + public Byte[] ColumnGeometry { get; set; } + public Byte[] ColumnLineString { get; set; } + public Byte[] ColumnMultiLineString { get; set; } + public Byte[] ColumnMultiPoint { get; set; } + public Byte[] ColumnMultiPolygon { get; set; } + public Byte[] ColumnPoint { get; set; } + public Byte[] ColumnPolygon { get; set; } + public Int64? ColumnBigint { get; set; } + public Decimal? ColumnDecimal { get; set; } + public Double? ColumnDouble { get; set; } + public Single? ColumnFloat { get; set; } + public Int32? ColumnInt2 { get; set; } + public Int32? ColumnMediumInt { get; set; } + public Double? ColumnReal { get; set; } + public Int16? ColumnSmallInt { get; set; } + public SByte? ColumnTinyInt { get; set; } + public String ColumnChar { get; set; } + public String ColumnJson { get; set; } + public String ColumnNChar { get; set; } + public String ColumnNVarChar { get; set; } + public String ColumnLongText { get; set; } + public String ColumnMediumText { get; set; } + public String ColumnText { get; set; } + public String ColumnTinyText { get; set; } + public UInt64? ColumnBit { get; set; } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageAllTest.cs new file mode 100644 index 000000000..ab88f11be --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageAllTest.cs @@ -0,0 +1,174 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class AverageAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionAverageAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAll(e => e.ColumnInt); + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionAverageAllWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAll(e => e.ColumnInt, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionAverageAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAllAsync(e => e.ColumnInt).Result; + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionAverageAllAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAllAsync(e => e.ColumnInt, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionAverageAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)); + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionAverageAllViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionAverageAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)).Result; + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionAverageAllAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageTest.cs new file mode 100644 index 000000000..bff93b37b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/AverageTest.cs @@ -0,0 +1,257 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class AverageTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionAverageWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Average(e => e.ColumnInt, + (object)null); + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionAverageWithExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var ids = new[] { tables.First().Id, tables.Last().Id }; + var result = connection.Average(e => e.ColumnInt, + e => ids.Contains(e.Id)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void TestMySqlConnectionAverageWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Average(e => e.ColumnInt, + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionAverageAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAsync(e => e.ColumnInt, + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionAverageAsyncWithExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var ids = new[] { tables.First().Id, tables.Last().Id }; + var result = connection.AverageAsync(e => e.ColumnInt, + e => ids.Contains(e.Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void TestMySqlConnectionAverageAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAsync(e => e.ColumnInt, + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionAverageViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Average(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + (object)null); + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionAverageViaTableNameWithExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var ids = new[] { tables.First().Id, tables.Last().Id }; + var result = connection.Average(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + new QueryField("Id", Operation.In, ids)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void TestMySqlConnectionAverageViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Average(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionAverageAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.AverageAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionAverageAsyncViaTableNameWithExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var ids = new[] { tables.First().Id, tables.Last().Id }; + var result = connection.AverageAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + new QueryField("Id", Operation.In, ids)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Average(e => e.ColumnInt), Convert.ToDouble(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void TestMySqlConnectionAverageAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.AverageAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/BatchQueryTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/BatchQueryTest.cs new file mode 100644 index 000000000..0036da90e --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/BatchQueryTest.cs @@ -0,0 +1,449 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class BatchQueryTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionBatchQueryFirstBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(0), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(2), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryFirstBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(0, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(9), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(7), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryThirdBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(2, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(6), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(8), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryThirdBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(2, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(3), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(1), result.ElementAt(2)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionBatchQueryWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.BatchQuery(0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionBatchQueryAsyncFirstBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(0), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(2), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryAsyncFirstBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(0, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(9), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(7), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryAsyncThirdBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(2, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(6), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(8), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryAsyncThirdBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(2, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertPropertiesEquality(tables.ElementAt(3), result.ElementAt(0)); + Helper.AssertPropertiesEquality(tables.ElementAt(1), result.ElementAt(2)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionBatchQueryAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.BatchQueryAsync(0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameFirstBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(0), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(2), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameFirstBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(9), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(7), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameThirdBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(ClassMappedNameCache.Get(), + 2, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(6), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(8), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameThirdBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQuery(ClassMappedNameCache.Get(), + 2, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null); + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(3), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(1), result.ElementAt(2)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionBatchQueryViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.BatchQuery(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameAsyncFirstBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(0), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(2), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameAsyncFirstBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(9), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(7), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameAsyncThirdBatchAscending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(ClassMappedNameCache.Get(), + 2, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(6), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(8), result.ElementAt(2)); + } + } + + [TestMethod] + public void TestMySqlConnectionBatchQueryViaTableNameAsyncThirdBatchDescending() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.BatchQueryAsync(ClassMappedNameCache.Get(), + 2, + 3, + OrderField.Descending(c => c.Id).AsEnumerable(), + (object)null).Result; + + // Assert + Helper.AssertMembersEquality(tables.ElementAt(3), result.ElementAt(0)); + Helper.AssertMembersEquality(tables.ElementAt(1), result.ElementAt(2)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionBatchQueryAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.BatchQueryAsync(ClassMappedNameCache.Get(), + 0, + 3, + OrderField.Ascending(c => c.Id).AsEnumerable(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountAllTest.cs new file mode 100644 index 000000000..694b86f83 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountAllTest.cs @@ -0,0 +1,168 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class CountAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionCountAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAll(); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionCountAllWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAll(hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionCountAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAllAsync().Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionCountAllAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAllAsync(hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionCountAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAll(ClassMappedNameCache.Get()); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionCountAllViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAll(ClassMappedNameCache.Get(), + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionCountAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAllAsync(ClassMappedNameCache.Get()).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionCountAllAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAllAsync(ClassMappedNameCache.Get(), + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountTest.cs new file mode 100644 index 000000000..4f2ed3b9d --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/CountTest.cs @@ -0,0 +1,517 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class CountTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionCountWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count((object)null); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(e => ids.Contains(e.Id)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionCountWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Count((object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionCountAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync((object)null).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(e => ids.Contains(e.Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionCountAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAsync((object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionCountViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(ClassMappedNameCache.Get(), + (object)null); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(ClassMappedNameCache.Get(), + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(ClassMappedNameCache.Get(), + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(ClassMappedNameCache.Get(), + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Count(ClassMappedNameCache.Get(), + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionCountViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Count(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(ClassMappedNameCache.Get(), + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(ClassMappedNameCache.Get(), + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(ClassMappedNameCache.Get(), + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(ClassMappedNameCache.Get(), + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionCountAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.CountAsync(ClassMappedNameCache.Get(), + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Count(), result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionCountAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.CountAsync(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteAllTest.cs new file mode 100644 index 000000000..71fad7993 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteAllTest.cs @@ -0,0 +1,249 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class DeleteAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionDeleteAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAll(); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllViaPrimaryKeys() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAll(primaryKeys); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllViaPrimaryKeysBeyondLimits() + { + // Setup + var tables = Database.CreateCompleteTables(5000); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAll(primaryKeys); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAllAsync().Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsyncViaPrimaryKeys() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAllAsync(primaryKeys).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsyncViaPrimaryKeysBeyondLimits() + { + // Setup + var tables = Database.CreateCompleteTables(5000); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAllAsync(primaryKeys).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionDeleteAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAll(ClassMappedNameCache.Get()); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllViaTableNameViaPrimaryKeys() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAll(ClassMappedNameCache.Get(), primaryKeys); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllViaTableNameViaPrimaryKeysBeyondLimits() + { + // Setup + var tables = Database.CreateCompleteTables(5000); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAll(ClassMappedNameCache.Get(), primaryKeys); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAllAsync(ClassMappedNameCache.Get()).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsyncViaTableNameViaPrimaryKeys() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAllAsync(ClassMappedNameCache.Get(), primaryKeys).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAllAsyncViaTableNameViaPrimaryKeysBeyondLimits() + { + // Setup + var tables = Database.CreateCompleteTables(5000); + var primaryKeys = ClassExpression.GetEntitiesPropertyValues(tables, e => e.Id); + + using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) + { + // Act + var result = connection.DeleteAllAsync(ClassMappedNameCache.Get(), primaryKeys).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteTest.cs new file mode 100644 index 000000000..30711b1a4 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/DeleteTest.cs @@ -0,0 +1,542 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class DeleteTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionDeleteWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete((object)null); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaPrimaryKey() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(tables.First().Id); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaDataEntity() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(tables.First()); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(e => e.Id == tables.First().Id); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(new { Id = tables.First().Id }); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(queryFields); + + // Assert + Assert.AreEqual(8, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(queryGroup); + + // Assert + Assert.AreEqual(8, result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync((object)null).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaPrimaryKey() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(tables.First().Id).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaDataEntity() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(tables.First()).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(e => e.Id == tables.First().Id).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(new { Id = tables.First().Id }).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(queryFields).Result; + + // Assert + Assert.AreEqual(8, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(queryGroup).Result; + + // Assert + Assert.AreEqual(8, result); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(ClassMappedNameCache.Get(), (object)null); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameViaPrimaryKey() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(tables.First().Id); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(ClassMappedNameCache.Get(), new { Id = tables.First().Id }); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(ClassMappedNameCache.Get(), new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(ClassMappedNameCache.Get(), queryFields); + + // Assert + Assert.AreEqual(8, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Delete(ClassMappedNameCache.Get(), queryGroup); + + // Assert + Assert.AreEqual(8, result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(ClassMappedNameCache.Get(), (object)null).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameViaPrimaryKey() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(tables.First().Id).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(ClassMappedNameCache.Get(), new { Id = tables.First().Id }).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(ClassMappedNameCache.Get(), new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(ClassMappedNameCache.Get(), queryFields).Result; + + // Assert + Assert.AreEqual(8, result); + } + } + + [TestMethod] + public void TestMySqlConnectionDeleteAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.DeleteAsync(ClassMappedNameCache.Get(), queryGroup).Result; + + // Assert + Assert.AreEqual(8, result); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteNonQueryTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteNonQueryTest.cs new file mode 100644 index 000000000..6aa522334 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteNonQueryTest.cs @@ -0,0 +1,130 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExecuteNonQueryTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExecuteNonQuery() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQuery("DELETE FROM `CompleteTable`;"); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteNonQueryWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQuery("DELETE FROM `CompleteTable` WHERE Id = @Id;", + new { tables.Last().Id }); + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteNonQueryWithMultipleStatement() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQuery("DELETE FROM `CompleteTable`; DELETE FROM `CompleteTable`;"); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExecuteNonQueryAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQueryAsync("DELETE FROM `CompleteTable`;").Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteNonQueryAsyncWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQueryAsync("DELETE FROM `CompleteTable` WHERE Id = @Id;", + new { tables.Last().Id }).Result; + + // Assert + Assert.AreEqual(1, result); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteNonQueryAsyncWithMultipleStatement() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteNonQueryAsync("DELETE FROM `CompleteTable`; DELETE FROM `CompleteTable`;").Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryMultipleTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryMultipleTest.cs new file mode 100644 index 000000000..79e277de7 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryMultipleTest.cs @@ -0,0 +1,211 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Collections.Generic; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExecuteQueryMultipleTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultiple() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultiple(@"SELECT * FROM `CompleteTable`; + SELECT * FROM `CompleteTable`;")) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + Assert.AreEqual(tables.Count(), item.Count()); + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, item.First(e => e.Id == table.Id))); + }); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultipleWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultiple(@"SELECT * FROM `CompleteTable` WHERE Id = @Id1; + SELECT * FROM `CompleteTable` WHERE Id = @Id2;", + new + { + Id1 = tables.First().Id, + Id2 = tables.Last().Id + })) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + item.AsList().ForEach(current => Helper.AssertPropertiesEquality(current, tables.First(e => e.Id == current.Id))); + }); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultipleWithSharedParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultiple(@"SELECT * FROM `CompleteTable` WHERE Id = @Id; + SELECT * FROM `CompleteTable` WHERE Id = @Id;", + new { Id = tables.Last().Id })) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + item.AsList().ForEach(current => Helper.AssertPropertiesEquality(current, tables.First(e => e.Id == current.Id))); + }); + } + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultipleAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultipleAsync(@"SELECT * FROM `CompleteTable`; + SELECT * FROM `CompleteTable`;").Result) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + Assert.AreEqual(tables.Count(), item.Count()); + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, item.First(e => e.Id == table.Id))); + }); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultipleAsyncWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultipleAsync(@"SELECT * FROM `CompleteTable` WHERE Id = @Id1; + SELECT * FROM `CompleteTable` WHERE Id = @Id2;", + new + { + Id1 = tables.First().Id, + Id2 = tables.Last().Id + }).Result) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + item.AsList().ForEach(current => Helper.AssertPropertiesEquality(current, tables.First(e => e.Id == current.Id))); + }); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryMultipleAsyncWithSharedParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var extractor = connection.ExecuteQueryMultipleAsync(@"SELECT * FROM `CompleteTable` WHERE Id = @Id; + SELECT * FROM `CompleteTable` WHERE Id = @Id;", + new { Id = tables.Last().Id }).Result) + { + var list = new List>(); + + // Act + list.Add(extractor.Extract()); + list.Add(extractor.Extract()); + + // Assert + list.ForEach(item => + { + item.AsList().ForEach(current => Helper.AssertPropertiesEquality(current, tables.First(e => e.Id == current.Id))); + }); + } + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryTest.cs new file mode 100644 index 000000000..0f05c3aaf --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteQueryTest.cs @@ -0,0 +1,104 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExecuteQueryTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExecuteQuery() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteQuery("SELECT * FROM `CompleteTable`;"); + + // Assert + Assert.AreEqual(tables.Count(), result.Count()); + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, result.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteQuery("SELECT * FROM `CompleteTable` WHERE Id = @Id;", + new { tables.Last().Id }); + + // Assert + Assert.AreEqual(1, result.Count()); + Helper.AssertPropertiesEquality(tables.Last(), result.First()); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExecuteQueryAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteQueryAsync("SELECT * FROM `CompleteTable`;").Result; + + // Assert + Assert.AreEqual(tables.Count(), result.Count()); + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, result.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteQueryAsyncWithParameters() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteQueryAsync("SELECT * FROM `CompleteTable` WHERE Id = @Id;", + new { tables.Last().Id }).Result; + + // Assert + Assert.AreEqual(1, result.Count()); + Helper.AssertPropertiesEquality(tables.Last(), result.First()); + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteReaderTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteReaderTest.cs new file mode 100644 index 000000000..ed07ad3f6 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteReaderTest.cs @@ -0,0 +1,234 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.Reflection; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Data.Common; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExecuteReaderTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExecuteReader() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReader("SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`;")) + { + while (reader.Read()) + { + // Act + var id = reader.GetInt64(0); + var columnInt = reader.GetInt32(1); + var columnDateTime = reader.GetDateTime(2); + var table = tables.FirstOrDefault(e => e.Id == id); + + // Assert + Assert.IsNotNull(table); + Assert.AreEqual(columnInt, table.ColumnInt); + Assert.AreEqual(columnDateTime, table.ColumnDateTime); + } + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderWithMultipleStatements() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReader("SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`; SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`;")) + { + do + { + while (reader.Read()) + { + // Act + var id = reader.GetInt64(0); + var columnInt = reader.GetInt32(1); + var columnDateTime = reader.GetDateTime(2); + var table = tables.FirstOrDefault(e => e.Id == id); + + // Assert + Assert.IsNotNull(table); + Assert.AreEqual(columnInt, table.ColumnInt); + Assert.AreEqual(columnDateTime, table.ColumnDateTime); + } + } while (reader.NextResult()); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsExtractedEntity() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReader("SELECT * FROM `CompleteTable`;")) + { + // Act + var result = DataReader.ToEnumerable((DbDataReader)reader, connection).AsList(); + + // Assert + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, result.First(e => e.Id == table.Id))); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsExtractedDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReader("SELECT * FROM `CompleteTable`;")) + { + // Act + var result = DataReader.ToEnumerable((DbDataReader)reader, connection).AsList(); + + // Assert + tables.AsList().ForEach(table => Helper.AssertMembersEquality(table, result.First(e => e.Id == table.Id))); + } + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReaderAsync("SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`;").Result) + { + while (reader.Read()) + { + // Act + var id = reader.GetInt64(0); + var columnInt = reader.GetInt32(1); + var columnDateTime = reader.GetDateTime(2); + var table = tables.FirstOrDefault(e => e.Id == id); + + // Assert + Assert.IsNotNull(table); + Assert.AreEqual(columnInt, table.ColumnInt); + Assert.AreEqual(columnDateTime, table.ColumnDateTime); + } + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsyncWithMultipleStatements() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReaderAsync("SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`; SELECT Id, ColumnInt, ColumnDateTime FROM `CompleteTable`;").Result) + { + do + { + while (reader.Read()) + { + // Act + var id = reader.GetInt64(0); + var columnInt = reader.GetInt32(1); + var columnDateTime = reader.GetDateTime(2); + var table = tables.FirstOrDefault(e => e.Id == id); + + // Assert + Assert.IsNotNull(table); + Assert.AreEqual(columnInt, table.ColumnInt); + Assert.AreEqual(columnDateTime, table.ColumnDateTime); + } + } while (reader.NextResult()); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsyncAsExtractedEntity() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReaderAsync("SELECT * FROM `CompleteTable`;").Result) + { + // Act + var result = DataReader.ToEnumerable((DbDataReader)reader, connection).AsList(); + + // Assert + tables.AsList().ForEach(table => Helper.AssertPropertiesEquality(table, result.First(e => e.Id == table.Id))); + } + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteReaderAsyncAsExtractedDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + using (var reader = connection.ExecuteReaderAsync("SELECT * FROM `CompleteTable`;").Result) + { + // Act + var result = DataReader.ToEnumerable((DbDataReader)reader, connection).AsList(); + + // Assert + tables.AsList().ForEach(table => Helper.AssertMembersEquality(table, result.First(e => e.Id == table.Id))); + } + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteScalarTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteScalarTest.cs new file mode 100644 index 000000000..fde67626e --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExecuteScalarTest.cs @@ -0,0 +1,97 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExecuteScalarTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExecuteScalar() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteScalar("SELECT COUNT(*) FROM `CompleteTable`;"); + + // Assert + Assert.AreEqual(tables.Count(), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteScalarWithReturnType() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteScalar("SELECT COUNT(*) FROM `CompleteTable`;"); + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExecuteScalarAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteScalarAsync("SELECT COUNT(*) FROM `CompleteTable`;").Result; + + // Assert + Assert.AreEqual(tables.Count(), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionExecuteScalarAsyncWithReturnType() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExecuteScalarAsync("SELECT COUNT(*) FROM `CompleteTable`;").Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExistsTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExistsTest.cs new file mode 100644 index 000000000..9d729f142 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/ExistsTest.cs @@ -0,0 +1,517 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class ExistsTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExistsWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists((object)null); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(e => ids.Contains(e.Id)); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(new { tables.First().Id }); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(new QueryField("Id", tables.First().Id)); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(queryFields); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(queryGroup); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionExistsWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Exists((object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExistsAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync((object)null).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(e => ids.Contains(e.Id)).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(new { tables.First().Id }).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(queryFields).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(queryGroup).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionExistsAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.ExistsAsync((object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionExistsViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(ClassMappedNameCache.Get(), + (object)null); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(ClassMappedNameCache.Get(), + new { tables.First().Id }); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(ClassMappedNameCache.Get(), + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(ClassMappedNameCache.Get(), + queryFields); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Exists(ClassMappedNameCache.Get(), + queryGroup); + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionExistsViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Exists(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(ClassMappedNameCache.Get(), + (object)null).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(ClassMappedNameCache.Get(), + new { tables.First().Id }).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(ClassMappedNameCache.Get(), + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(ClassMappedNameCache.Get(), + queryFields).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod] + public void TestMySqlConnectionExistsAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.ExistsAsync(ClassMappedNameCache.Get(), + queryGroup).Result; + + // Assert + Assert.IsTrue(result); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionExistsAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.ExistsAsync(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertAllTest.cs new file mode 100644 index 000000000..2c0e69113 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertAllTest.cs @@ -0,0 +1,359 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class InsertAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionInsertAllForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + Assert.IsTrue(tables.All(table => table.Id > 0)); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertPropertiesEquality(table, queryResult.First(item => item.Id == table.Id)); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertPropertiesEquality(table, queryResult.First(item => item.Id == table.Id)); + }); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionInsertAllAsyncForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + Assert.IsTrue(tables.All(table => table.Id > 0)); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertPropertiesEquality(table, queryResult.First(item => item.Id == table.Id)); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllAsyncForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertPropertiesEquality(table, queryResult.First(item => item.Id == table.Id)); + }); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameAsDynamicsForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTablesAsDynamics(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameAsDynamicsForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTablesAsDynamics(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table))); + }); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameAsyncForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllAsyncViaTableNameAsDynamicsForIdentity() + { + // Setup + var tables = Helper.CreateCompleteTablesAsDynamics(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllViaTableNameAsyncForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table))); + }); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAllAsyncViaTableNameAsDynamicsForNonIdentity() + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTablesAsDynamics(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.ForEach(table => + { + Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table))); + }); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertTest.cs new file mode 100644 index 000000000..d52d99a47 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/InsertTest.cs @@ -0,0 +1,336 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class InsertTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionInsertForIdentity() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(table); + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + Assert.IsTrue(table.Id > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(table); + + // Assert + Assert.AreEqual(table.Id, result); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionInsertAsyncForIdentity() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(table).Result; + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + Assert.IsTrue(table.Id > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAsyncForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(table).Result; + + // Assert + Assert.AreEqual(table.Id, result); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameForIdentity() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(ClassMappedNameCache.Get(), + table); + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameAsDynamicForIdentity() + { + // Setup + var table = Helper.CreateCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(ClassMappedNameCache.Get(), + (object)table); + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(queryResult.First(), table); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(ClassMappedNameCache.Get(), + table); + + // Assert + Assert.AreEqual(table.Id, result); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameAsDynamicForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Insert(ClassMappedNameCache.Get(), + (object)table); + + // Assert + Assert.AreEqual(table.Id, result); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(queryResult.First(), table); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameAsyncForIdentity() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(ClassMappedNameCache.Get(), + table).Result; + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAsyncViaTableNameAsDynamicForIdentity() + { + // Setup + var table = Helper.CreateCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(ClassMappedNameCache.Get(), + (object)table).Result; + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(queryResult.First(), table); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertViaTableNameAsyncForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(ClassMappedNameCache.Get(), + table).Result; + + // Assert + Assert.IsTrue(Convert.ToInt64(result) > 0); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionInsertAsyncViaTableNameAsDynamicForNonIdentity() + { + // Setup + var table = Helper.CreateNonIdentityCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.InsertAsync(ClassMappedNameCache.Get(), + (object)table).Result; + + // Assert + Assert.AreEqual(table.Id, result); + + // Act + var queryResult = connection.Query(result); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(queryResult.First(), table); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxAllTest.cs new file mode 100644 index 000000000..46e208994 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxAllTest.cs @@ -0,0 +1,174 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MaxAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMaxAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAll(e => e.ColumnInt); + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMaxAllWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAll(e => e.ColumnInt, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMaxAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAllAsync(e => e.ColumnInt).Result; + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMaxAllAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAllAsync(e => e.ColumnInt, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMaxAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)); + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMaxAllViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMaxAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)).Result; + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMaxAllAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxTest.cs new file mode 100644 index 000000000..c766825b9 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MaxTest.cs @@ -0,0 +1,543 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MaxTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMaxWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + (object)null); + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + e => ids.Contains(e.Id)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(e => e.ColumnInt, + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMaxWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Max(e => e.ColumnInt, + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMaxAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + e => ids.Contains(e.Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(e => e.ColumnInt, + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMaxAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAsync(e => e.ColumnInt, + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMaxViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null); + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMaxViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Max(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMaxAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Max(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMaxAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MaxAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeAllTest.cs new file mode 100644 index 000000000..6aa637060 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeAllTest.cs @@ -0,0 +1,975 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Setup; +using RepoDb.MySql.IntegrationTests.Models; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MergeAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMergeAllForIdentityForEmptyTable() + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAll(tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(tables, + qualifiers); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + // Act + var result = connection.MergeAll(tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(tables); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(tables, + qualifiers); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + // Act + var result = connection.MergeAllAsync(tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(tables, + qualifiers).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + // Act + var result = connection.MergeAllAsync(tables).Result; + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(tables, + qualifiers).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables, + qualifiers); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateCompleteTablesAsDynamics(10); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + entities); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + entities, + qualifiers); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables, + qualifiers); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTablesAsDynamics(10); + + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + tables); + + // Assert + Assert.AreEqual(tables.Count(), result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + entities); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsDynamicsViaTableNameForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAll(ClassMappedNameCache.Get(), + entities, + qualifiers); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameAsyncForIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateCompleteTables(10); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameAsyncForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllViaTableNameAsyncForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables, + qualifiers).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateCompleteTablesAsDynamics(10); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + entities).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + entities, + qualifiers).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncViaTableNameForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTables(10); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncViaTableNameForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncViaTableNameForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.ForEach(table => Helper.UpdateNonIdentityCompleteTableProperties(table)); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables, + qualifiers).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt(tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForNonIdentityForEmptyTable() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + var tables = Helper.CreateNonIdentityCompleteTablesAsDynamics(10); + + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + tables).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + tables.ForEach(table => Helper.AssertMembersEquality(table, queryResult.ElementAt((int)tables.IndexOf(table)))); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForNonIdentityForNonEmptyTable() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + entities).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAllAsyncAsDynamicsViaTableNameForNonIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var tables = Database.CreateNonIdentityCompleteTables(10).AsList(); + var entities = tables.Select(table => new + { + Id = table.Id, + ColumnInt = int.MaxValue + }).AsList(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAllAsync(ClassMappedNameCache.Get(), + entities, + qualifiers).Result; + + // Act + var queryResult = connection.QueryAll(); + + // Assert + Assert.AreEqual(tables.Count(), queryResult.Count()); + entities.ForEach(table => Assert.AreEqual(table.ColumnInt, queryResult.ElementAt((int)entities.IndexOf(table)).ColumnInt)); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeTest.cs new file mode 100644 index 000000000..2ddb6a51a --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MergeTest.cs @@ -0,0 +1,536 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MergeTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMergeForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Merge(table); + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Merge(table); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + table.ColumnInt = 0; + table.ColumnChar = "C"; + + // Act + var result = connection.Merge(table, + qualifiers); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMergeAsyncForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAsync(table).Result; + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.MergeAsync(table).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + table.ColumnInt = 0; + table.ColumnChar = "C"; + + // Act + var result = connection.MergeAsync(table, + qualifiers).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertPropertiesEquality(table, queryResult.First()); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMergeViaTableNameForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + table); + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + table); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + table.ColumnInt = 0; + table.ColumnChar = "C"; + + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + table, + qualifiers); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsDynamicViaTableNameForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + (object)table); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsDynamicViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var obj = new + { + table.Id, + ColumnInt = int.MaxValue + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + (object)obj); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.IsTrue(queryResult.Count() > 0); + Assert.AreEqual(obj.ColumnInt, queryResult.First().ColumnInt); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsDynamicViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var obj = new + { + table.Id, + ColumnInt = int.MaxValue + }; + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Merge(ClassMappedNameCache.Get(), + (object)obj, + qualifiers); + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.IsTrue(queryResult.Count() > 0); + Assert.AreEqual(obj.ColumnInt, queryResult.First().ColumnInt); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMergeAsyncViaTableNameForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + table).Result; + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + table).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + table, + qualifiers).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncAsDynamicViaTableNameForIdentityForEmptyTable() + { + // Setup + var table = Helper.CreateCompleteTablesAsDynamics(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + (object)table).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.AreEqual(1, queryResult?.Count()); + Helper.AssertMembersEquality(table, queryResult.First()); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncAsDynamicViaTableNameForIdentityForNonEmptyTable() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var obj = new + { + table.Id, + ColumnInt = int.MaxValue + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + (object)obj).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.IsTrue(queryResult.Count() > 0); + Assert.AreEqual(obj.ColumnInt, queryResult.First().ColumnInt); + } + } + + [TestMethod] + public void TestMySqlConnectionMergeAsyncAsDynamicViaTableNameForIdentityForNonEmptyTableWithQualifiers() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var obj = new + { + table.Id, + ColumnInt = int.MaxValue + }; + var qualifiers = new[] + { + new Field("Id", typeof(long)) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MergeAsync(ClassMappedNameCache.Get(), + (object)obj, + qualifiers).Result; + + // Assert + Assert.AreEqual(table.Id, Convert.ToInt64(result)); + + // Act + var queryResult = connection.Query(Convert.ToInt64(result)); + + // Assert + Assert.IsTrue(queryResult.Count() > 0); + Assert.AreEqual(obj.ColumnInt, queryResult.First().ColumnInt); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinAllTest.cs new file mode 100644 index 000000000..ee1a57556 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinAllTest.cs @@ -0,0 +1,174 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MinAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMinAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAll(e => e.ColumnInt); + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMinAllWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAll(e => e.ColumnInt, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMinAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAllAsync(e => e.ColumnInt).Result; + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMinAllAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAllAsync(e => e.ColumnInt, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMinAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)); + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMinAllViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMinAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)).Result; + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMinAllAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinTest.cs new file mode 100644 index 000000000..fa1f4908d --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/MinTest.cs @@ -0,0 +1,543 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class MinTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMinWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + (object)null); + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + e => ids.Contains(e.Id)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(e => e.ColumnInt, + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMinWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Min(e => e.ColumnInt, + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMinAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + e => ids.Contains(e.Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(e => e.ColumnInt, + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMinAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAsync(e => e.ColumnInt, + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionMinViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null); + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionMinViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Min(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionMinAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Min(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionMinAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.MinAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryAllTest.cs new file mode 100644 index 000000000..10b3b8f86 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryAllTest.cs @@ -0,0 +1,175 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class QueryAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionQueryAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionQueryAllWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryAll(hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionQueryAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionQueryAllAsyncWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryAllAsync(hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionQueryAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var queryResult = connection.QueryAll(ClassMappedNameCache.Get()); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertMembersEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionQueryAllViaTableNameWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Query(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionQueryAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var queryResult = connection.QueryAllAsync(ClassMappedNameCache.Get()).Result; + + // Assert + tables.AsList().ForEach(table => + Helper.AssertMembersEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionQueryAllAsyncViaTableNameWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryAsync(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryMultipleTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryMultipleTest.cs new file mode 100644 index 000000000..c34149b7b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryMultipleTest.cs @@ -0,0 +1,459 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class QueryMultipleTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT2() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT3() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT4() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT5() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT6() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5, + top6: 6); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + Assert.AreEqual(6, result.Item6.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item6.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleForT7() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5, + top6: 6, + top7: 7); + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + Assert.AreEqual(6, result.Item6.Count()); + Assert.AreEqual(7, result.Item7.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item6.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item7.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionQueryMultipleWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryMultiple(e => e.Id > 0, + e => e.Id > 0, + top1: 1, + hints1: "WhatEver", + top2: 2, + hints2: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT2() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT3() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT4() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT5() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT6() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5, + top6: 6).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + Assert.AreEqual(6, result.Item6.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item6.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryMultipleAsyncForT7() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + e => e.Id > 0, + top1: 1, + top2: 2, + top3: 3, + top4: 4, + top5: 5, + top6: 6, + top7: 7).Result; + + // Assert + Assert.AreEqual(1, result.Item1.Count()); + Assert.AreEqual(2, result.Item2.Count()); + Assert.AreEqual(3, result.Item3.Count()); + Assert.AreEqual(4, result.Item4.Count()); + Assert.AreEqual(5, result.Item5.Count()); + Assert.AreEqual(6, result.Item6.Count()); + Assert.AreEqual(7, result.Item7.Count()); + result.Item1.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item2.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item3.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item4.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item5.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item6.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + result.Item7.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionQueryMultipleAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryMultipleAsync(e => e.Id > 0, + e => e.Id > 0, + top1: 1, + hints1: "WhatEver", + top2: 2, + hints2: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryTest.cs new file mode 100644 index 000000000..9efbe44a3 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/QueryTest.cs @@ -0,0 +1,579 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class QueryTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionQueryViaPrimaryKey() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaExpression() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(e => e.Id == table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(new { table.Id }).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(new QueryField("Id", table.Id)).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(queryFields).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(queryGroup).First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryWithTop() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query((object)null, + top: 2); + + // Assert + Assert.AreEqual(2, result.Count()); + result.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionQueryWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Query((object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaPrimaryKey() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(table.Id).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaExpression() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(e => e.Id == table.Id).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(new { table.Id }).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(new QueryField("Id", table.Id)).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(queryFields).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(queryGroup).Result.First(); + + // Assert + Helper.AssertPropertiesEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncWithTop() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync((object)null, + top: 2).Result; + + // Assert + Assert.AreEqual(2, result.Count()); + result.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionQueryAsyncWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryAsync((object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameViaPrimaryKey() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), new { table.Id }).First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), new QueryField("Id", table.Id)).First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), queryFields).First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), queryGroup).First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryViaTableNameWithTop() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Query(ClassMappedNameCache.Get(), + (object)null, + top: 2); + + // Assert + Assert.AreEqual(2, result.Count()); + result.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionQueryViaTableNameWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Query(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameViaPrimaryKey() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), table.Id).Result.First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), new { table.Id }).Result.First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), new QueryField("Id", table.Id)).Result.First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), queryFields).Result.First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), queryGroup).Result.First(); + + // Assert + Helper.AssertMembersEquality(table, result); + } + } + + [TestMethod] + public void TestMySqlConnectionQueryAsyncViaTableNameWithTop() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.QueryAsync(ClassMappedNameCache.Get(), + (object)null, + top: 2).Result; + + // Assert + Assert.AreEqual(2, result.Count()); + result.AsList().ForEach(item => Helper.AssertPropertiesEquality(tables.First(e => e.Id == item.Id), item)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionQueryAsyncViaTableNameWithHints() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.QueryAsync(ClassMappedNameCache.Get(), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumAllTest.cs new file mode 100644 index 000000000..180500986 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumAllTest.cs @@ -0,0 +1,174 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class SumAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionSumAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAll(e => e.ColumnInt); + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionSumAllWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAll(e => e.ColumnInt, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionSumAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAllAsync(e => e.ColumnInt).Result; + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionSumAllAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAllAsync(e => e.ColumnInt, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionSumAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)); + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionSumAllViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAll(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionSumAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt)).Result; + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionSumAllAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAllAsync(ClassMappedNameCache.Get(), + Field.Parse(e => e.ColumnInt), + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumTest.cs new file mode 100644 index 000000000..6ffb7898b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/SumTest.cs @@ -0,0 +1,543 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class SumTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionSumWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + (object)null); + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + e => ids.Contains(e.Id)); + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(e => e.ColumnInt, + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionSumWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Sum(e => e.ColumnInt, + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionSumAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var ids = new[] { tables.First().Id, tables.Last().Id }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + e => ids.Contains(e.Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => ids.Contains(e.Id)).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(e => e.ColumnInt, + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionSumAsyncWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAsync(e => e.ColumnInt, + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionSumViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null); + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup); + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlConnectionSumViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Sum(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver"); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null).Result; + + // Assert + Assert.AreEqual(tables.Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaTableNameViaDynamic() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new { tables.First().Id }).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaTableNameViaQueryField() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + new QueryField("Id", tables.First().Id)).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id == tables.First().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaTableNameViaQueryFields() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryFields).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod] + public void TestMySqlConnectionSumAsyncViaTableNameViaQueryGroup() + { + // Setup + var tables = Database.CreateCompleteTables(10); + var queryFields = new[] + { + new QueryField("Id", Operation.GreaterThan, tables.First().Id), + new QueryField("Id", Operation.LessThan, tables.Last().Id) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + queryGroup).Result; + + // Assert + Assert.AreEqual(tables.Where(e => e.Id > tables.First().Id && e.Id < tables.Last().Id).Sum(e => e.ColumnInt), Convert.ToInt32(result)); + } + } + + [TestMethod, ExpectedException(typeof(AggregateException))] + public void ThrowExceptionOnMySqlConnectionSumAsyncViaTableNameWithHints() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.SumAsync(ClassMappedNameCache.Get(), + new Field("ColumnInt", typeof(int)), + (object)null, + hints: "WhatEver").Wait(); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/TruncateTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/TruncateTest.cs new file mode 100644 index 000000000..3171f7e9c --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/TruncateTest.cs @@ -0,0 +1,116 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class TruncateTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionTruncate() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Truncate(); + var countResult = connection.CountAll(); + + // Assert + Assert.AreEqual(0, countResult); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionTruncateAsyncWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.TruncateAsync().Result; + var countResult = connection.CountAll(); + + // Assert + Assert.AreEqual(0, countResult); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionTruncateViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.Truncate(ClassMappedNameCache.Get()); + var countResult = connection.CountAll(); + + // Assert + Assert.AreEqual(0, countResult); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionTruncateAsyncViaTableNameWithoutExpression() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + var result = connection.TruncateAsync(ClassMappedNameCache.Get()).Result; + var countResult = connection.CountAll(); + + // Assert + Assert.AreEqual(0, countResult); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateAllTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateAllTest.cs new file mode 100644 index 000000000..e0d7baab4 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateAllTest.cs @@ -0,0 +1,154 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class UpdateAllTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionUpdateAll() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.AsList().ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.UpdateAll(tables); + + // Assert + Assert.AreEqual(10, result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionUpdateAllAsync() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.AsList().ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.UpdateAllAsync(tables).Result; + + // Assert + Assert.AreEqual(10, result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionUpdateAllViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.AsList().ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.UpdateAll(ClassMappedNameCache.Get(), tables); + + // Assert + Assert.AreEqual(10, result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionUpdateAllAsyncViaTableName() + { + // Setup + var tables = Database.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + tables.AsList().ForEach(table => Helper.UpdateCompleteTableProperties(table)); + + // Act + var result = connection.UpdateAllAsync(ClassMappedNameCache.Get(), tables).Result; + + // Assert + Assert.AreEqual(10, result); + + // Act + var queryResult = connection.QueryAll(); + + // Assert + tables.AsList().ForEach(table => + Helper.AssertPropertiesEquality(table, queryResult.First(e => e.Id == table.Id))); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateTest.cs new file mode 100644 index 000000000..4523fdf90 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Operations/UpdateTest.cs @@ -0,0 +1,643 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests.Operations +{ + [TestClass] + public class UpdateTest + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + #region DataEntity + + #region Sync + + [TestMethod] + public void TestMySqlConnectionUpdateViaDataEntity() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaExpression() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table, e => e.Id == table.Id); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table, new { table.Id }); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table, new QueryField("Id", table.Id)); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table, queryFields); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.Update(table, queryGroup); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaDataEntity() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaExpression() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table, e => e.Id == table.Id).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table, new { table.Id }).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table, new QueryField("Id", table.Id)).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table, queryFields).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(table, queryGroup).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + #endregion + + #endregion + + #region TableName + + #region Sync + + [TestMethod] + public void TestMySqlConnectionUpdateViaTableNameViaDataEntity() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = DbConnectionExtension.Update(connection, ClassMappedNameCache.Get(), table); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaTableNameViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = DbConnectionExtension.Update(connection, ClassMappedNameCache.Get(), table, new { table.Id }); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaTableNameViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = DbConnectionExtension.Update(connection, ClassMappedNameCache.Get(), table, new QueryField("Id", table.Id)); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaTableNameViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = DbConnectionExtension.Update(connection, ClassMappedNameCache.Get(), table, queryFields); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateViaTableNameViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = DbConnectionExtension.Update(connection, ClassMappedNameCache.Get(), table, queryGroup); + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + #endregion + + #region Async + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaTableNameViaDataEntity() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(ClassMappedNameCache.Get(), table).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaTableNameViaDynamic() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(ClassMappedNameCache.Get(), table, new { table.Id }).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaTableNameViaQueryField() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(ClassMappedNameCache.Get(), table, new QueryField("Id", table.Id)).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaTableNameViaQueryFields() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(ClassMappedNameCache.Get(), table, queryFields).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + [TestMethod] + public void TestMySqlConnectionUpdateAsyncViaTableNameViaQueryGroup() + { + // Setup + var table = Database.CreateCompleteTables(1).First(); + var queryFields = new[] + { + new QueryField("Id", table.Id), + new QueryField("ColumnInt", table.ColumnInt) + }; + var queryGroup = new QueryGroup(queryFields); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Setup + Helper.UpdateCompleteTableProperties(table); + + // Act + var result = connection.UpdateAsync(ClassMappedNameCache.Get(), table, queryGroup).Result; + + // Assert + Assert.AreEqual(1, result); + + // Act + var queryResult = connection.Query(ClassMappedNameCache.Get(), table.Id).First(); + + // Assert + Helper.AssertPropertiesEquality(table, queryResult); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/RepoDb.MySql.IntegrationTests.csproj b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/RepoDb.MySql.IntegrationTests.csproj new file mode 100644 index 000000000..2f31bb96b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/RepoDb.MySql.IntegrationTests.csproj @@ -0,0 +1,30 @@ + + + + netcoreapp3.1 + + false + + + + portable + true + + + + + + + + + + + + + + + + + + + diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Setup/Database.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Setup/Database.cs new file mode 100644 index 000000000..8937514a2 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/Setup/Database.cs @@ -0,0 +1,213 @@ +using RepoDb.MySql.IntegrationTests.Models; +using MySql.Data.MySqlClient; +using System; +using System.Collections.Generic; + +namespace RepoDb.MySql.IntegrationTests.Setup +{ + public static class Database + { + #region Properties + + /// + /// Gets or sets the connection string to be used for sys. + /// + public static string ConnectionStringForSys { get; private set; } + + /// + /// Gets or sets the connection string to be used. + /// + public static string ConnectionString { get; private set; } + + #endregion + + #region Methods + + public static void Initialize() + { + // Get the connection string + var connectionStringForSys = Environment.GetEnvironmentVariable("REPODB_CONSTR_SYS", EnvironmentVariableTarget.Process); + var connectionString = Environment.GetEnvironmentVariable("REPODB_CONSTR", EnvironmentVariableTarget.Process); + + // Set the connection string + ConnectionStringForSys = (connectionStringForSys ?? @"Server=localhost;Database=sys;Uid=user;Pwd=Password123;"); + ConnectionString = (connectionString ?? @"Server=localhost;Database=RepoDb;Uid=user;Pwd=Password123;"); + + // Initialize MySql + MySqlBootstrap.Initialize(); + + // Create databases + CreateDatabase(); + + // Create tables + CreateTables(); + } + + public static void Cleanup() + { + using (var connection = new MySqlConnection(ConnectionString)) + { + connection.DeleteAll(); + connection.DeleteAll(); + } + } + + #endregion + + #region CompleteTable + + public static IEnumerable CreateCompleteTables(int count) + { + using (var connection = new MySqlConnection(ConnectionString)) + { + var tables = Helper.CreateCompleteTables(count); + connection.InsertAll(tables); + return tables; + } + } + + #endregion + + #region NonIdentityCompleteTable + + public static IEnumerable CreateNonIdentityCompleteTables(int count) + { + using (var connection = new MySqlConnection(ConnectionString)) + { + var tables = Helper.CreateNonIdentityCompleteTables(count); + connection.InsertAll(tables); + return tables; + } + } + + #endregion + + #region CreateDatabases + + private static void CreateDatabase() + { + using (var connection = new MySqlConnection(ConnectionStringForSys)) + { + connection.ExecuteNonQuery(@"CREATE SCHEMA IF NOT EXISTS `RepoDb`;"); + } + } + + #endregion + + #region CreateTables + + private static void CreateTables() + { + CreateCompleteTable(); + CreateNonIdentityCompleteTable(); + } + + private static void CreateCompleteTable() + { + using (var connection = new MySqlConnection(ConnectionString)) + { + connection.ExecuteNonQuery(@"CREATE TABLE IF NOT EXISTS `completetable` + ( + `Id` bigint(20) NOT NULL AUTO_INCREMENT, + `ColumnVarchar` varchar(256) DEFAULT NULL, + `ColumnInt` int(11) DEFAULT NULL, + `ColumnDecimal2` decimal(18,2) DEFAULT NULL, + `ColumnDateTime` datetime DEFAULT NULL, + `ColumnBlob` blob, + `ColumnBlobAsArray` blob, + `ColumnBinary` binary(255) DEFAULT NULL, + `ColumnLongBlob` longblob, + `ColumnMediumBlob` mediumblob, + `ColumnTinyBlob` tinyblob, + `ColumnVarBinary` varbinary(256) DEFAULT NULL, + `ColumnDate` date DEFAULT NULL, + `ColumnDateTime2` datetime(5) DEFAULT NULL, + `ColumnTime` time DEFAULT NULL, + `ColumnTimeStamp` timestamp(5) NULL DEFAULT NULL, + `ColumnYear` year(4) DEFAULT NULL, + `ColumnGeometry` geometry DEFAULT NULL, + `ColumnLineString` linestring DEFAULT NULL, + `ColumnMultiLineString` multilinestring DEFAULT NULL, + `ColumnMultiPoint` multipoint DEFAULT NULL, + `ColumnMultiPolygon` multipolygon DEFAULT NULL, + `ColumnPoint` point DEFAULT NULL, + `ColumnPolygon` polygon DEFAULT NULL, + `ColumnBigint` bigint(64) DEFAULT NULL, + `ColumnDecimal` decimal(10,0) DEFAULT NULL, + `ColumnDouble` double DEFAULT NULL, + `ColumnFloat` float DEFAULT NULL, + `ColumnInt2` int(32) DEFAULT NULL, + `ColumnMediumInt` mediumint(16) DEFAULT NULL, + `ColumnReal` double DEFAULT NULL, + `ColumnSmallInt` smallint(8) DEFAULT NULL, + `ColumnTinyInt` tinyint(4) DEFAULT NULL, + `ColumnChar` char(1) DEFAULT NULL, + `ColumnJson` json DEFAULT NULL, + `ColumnNChar` nchar(16) DEFAULT NULL, + `ColumnNVarChar` nvarchar(256) DEFAULT NULL, + `ColumnLongText` longtext, + `ColumnMediumText` mediumtext, + `ColumnText` text, + `ColumnTinyText` tinytext, + `ColumnBit` bit(1) DEFAULT NULL, + PRIMARY KEY (`Id`) + ) ENGINE=InnoDB;"); + } + } + + private static void CreateNonIdentityCompleteTable() + { + using (var connection = new MySqlConnection(ConnectionString)) + { + connection.ExecuteNonQuery(@"CREATE TABLE IF NOT EXISTS `nonidentitycompletetable` + ( + `Id` bigint(20) NOT NULL, + `ColumnVarchar` varchar(256) DEFAULT NULL, + `ColumnInt` int(11) DEFAULT NULL, + `ColumnDecimal2` decimal(18, 2) DEFAULT NULL, + `ColumnDateTime` datetime DEFAULT NULL, + `ColumnBlob` blob, + `ColumnBlobAsArray` blob, + `ColumnBinary` binary(255) DEFAULT NULL, + `ColumnLongBlob` longblob, + `ColumnMediumBlob` mediumblob, + `ColumnTinyBlob` tinyblob, + `ColumnVarBinary` varbinary(256) DEFAULT NULL, + `ColumnDate` date DEFAULT NULL, + `ColumnDateTime2` datetime(5) DEFAULT NULL, + `ColumnTime` time DEFAULT NULL, + `ColumnTimeStamp` timestamp(5) NULL DEFAULT NULL, + `ColumnYear` year(4) DEFAULT NULL, + `ColumnGeometry` geometry DEFAULT NULL, + `ColumnLineString` linestring DEFAULT NULL, + `ColumnMultiLineString` multilinestring DEFAULT NULL, + `ColumnMultiPoint` multipoint DEFAULT NULL, + `ColumnMultiPolygon` multipolygon DEFAULT NULL, + `ColumnPoint` point DEFAULT NULL, + `ColumnPolygon` polygon DEFAULT NULL, + `ColumnBigint` bigint(64) DEFAULT NULL, + `ColumnDecimal` decimal(10, 0) DEFAULT NULL, + `ColumnDouble` double DEFAULT NULL, + `ColumnFloat` float DEFAULT NULL, + `ColumnInt2` int(32) DEFAULT NULL, + `ColumnMediumInt` mediumint(16) DEFAULT NULL, + `ColumnReal` double DEFAULT NULL, + `ColumnSmallInt` smallint(8) DEFAULT NULL, + `ColumnTinyInt` tinyint(4) DEFAULT NULL, + `ColumnChar` char(1) DEFAULT NULL, + `ColumnJson` json DEFAULT NULL, + `ColumnNChar` nchar(16) DEFAULT NULL, + `ColumnNVarChar` nvarchar(256) DEFAULT NULL, + `ColumnLongText` longtext, + `ColumnMediumText` mediumtext, + `ColumnText` text, + `ColumnTinyText` tinytext, + `ColumnBit` bit(1) DEFAULT NULL, + PRIMARY KEY(`Id`) + ) ENGINE = InnoDB;"); + } + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/TransactionTests.cs b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/TransactionTests.cs new file mode 100644 index 000000000..869cc22a5 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/TransactionTests.cs @@ -0,0 +1,1422 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.MySql.IntegrationTests.Models; +using RepoDb.MySql.IntegrationTests.Setup; +using System.Linq; + +namespace RepoDb.MySql.IntegrationTests +{ + [TestClass] + public class TransactionTests + { + [TestInitialize] + public void Initialize() + { + Database.Initialize(); + Cleanup(); + } + + [TestCleanup] + public void Cleanup() + { + Database.Cleanup(); + } + + /* + * Some tests here are only triggers (ie: BatchQuery, Count, CountAll, Query, QueryAll, Truncate) + */ + + #region BatchQuery + + #region BatchQuery + + [TestMethod] + public void TestSqlTransactionForBatchQuery() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.BatchQuery(0, 10, OrderField.Parse(new { Id = Order.Ascending }), it => it.Id != 0, transaction: transaction); + } + } + } + + #endregion + + #region BatchQueryAsync + + [TestMethod] + public void TestSqlTransactionForBatchQueryAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.BatchQueryAsync(0, 10, OrderField.Parse(new { Id = Order.Ascending }), it => it.Id != 0, transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region Count + + #region Count + + [TestMethod] + public void TestSqlTransactionForCount() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Count(it => it.Id != 0, transaction: transaction); + } + } + } + + #endregion + + #region CountAsync + + [TestMethod] + public void TestSqlTransactionForCountAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.CountAsync(it => it.Id != 0, transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region CountAll + + #region CountAll + + [TestMethod] + public void TestSqlTransactionForCountAll() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.CountAll(transaction: transaction); + } + } + } + + #endregion + + #region CountAllAsync + + [TestMethod] + public void TestSqlTransactionForCountAllAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.CountAllAsync(transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region Delete + + #region Delete + + [TestMethod] + public void TestSqlTransactionForDeleteAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Delete(entity, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForDeleteAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Delete(entity, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + #endregion + + #region DeleteAsync + + [TestMethod] + public void TestSqlTransactionForDeleteAsyncAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForDeleteAsyncAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region DeleteAll + + #region DeleteAll + + [TestMethod] + public void TestSqlTransactionForDeleteAllAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAll(transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForDeleteAllAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAll(transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + #endregion + + #region DeleteAllAsync + + [TestMethod] + public void TestSqlTransactionForDeleteAllAsyncAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAllAsync(transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForDeleteAllAsyncAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.DeleteAllAsync(transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region Insert + + #region Insert + + [TestMethod] + public void TestSqlTransactionForInsertAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Insert(entity, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForInsertAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Insert(entity, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #region InsertAsync + + [TestMethod] + public void TestSqlTransactionForInsertAsyncAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForInsertAsyncAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region InsertAll + + #region InsertAll + + [TestMethod] + public void TestSqlTransactionForInsertAllAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAll(entities, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForInsertAllAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAll(entities, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #region InsertAllAsync + + [TestMethod] + public void TestSqlTransactionForInsertAllAsyncAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForInsertAllAsyncAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.InsertAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region Merge + + #region Merge + + [TestMethod] + public void TestSqlTransactionForMergeAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Merge(entity, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForMergeAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Merge(entity, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #region MergeAsync + + [TestMethod] + public void TestSqlTransactionForMergeAsyncAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + var transaction = connection.EnsureOpen().BeginTransaction(); + + // Act + connection.MergeAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + + // Assert + Assert.AreEqual(1, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForMergeAsyncAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + var transaction = connection.EnsureOpen().BeginTransaction(); + + // Act + connection.MergeAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region MergeAll + + #region MergeAll + + [TestMethod] + public void TestSqlTransactionForMergeAllAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.MergeAll(entities, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForMergeAllAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.MergeAll(entities, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #region MergeAllAsync + + [TestMethod] + public void TestSqlTransactionForMergeAllAsyncAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.MergeAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Assert + Assert.AreEqual(entities.Count, connection.CountAll()); + } + } + + [TestMethod] + public void TestSqlTransactionForMergeAllAsyncAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.MergeAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Assert + Assert.AreEqual(0, connection.CountAll()); + } + } + + #endregion + + #endregion + + #region Query + + #region Query + + [TestMethod] + public void TestSqlTransactionForQuery() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Query(it => it.Id != 0, transaction: transaction); + } + } + } + + #endregion + + #region QueryAsync + + [TestMethod] + public void TestSqlTransactionForQueryAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryAsync(it => it.Id != 0, transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region QueryAll + + #region QueryAll + + [TestMethod] + public void TestSqlTransactionForQueryAll() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryAll(transaction: transaction); + } + } + } + + #endregion + + #region QueryAllAsync + + [TestMethod] + public void TestSqlTransactionForQueryAllAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryAllAsync(transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region QueryMultiple + + #region QueryMultiple + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT2() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT3() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT4() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT5() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT6() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleT7() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultiple(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction); + } + } + } + + #endregion + + #region QueryMultipleAsync + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT2() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT3() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT4() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT5() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT6() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + [TestMethod] + public void TestSqlTransactionForQueryMultipleAsyncT7() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.QueryMultipleAsync(it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + it => it.Id != 0, + transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region Truncate + + #region Truncate + + [TestMethod] + public void TestSqlTransactionForTruncate() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.Truncate(transaction: transaction); + } + } + } + + #endregion + + #region TruncateAsync + + [TestMethod] + public void TestSqlTransactionForTruncateAsync() + { + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + // Act + connection.TruncateAsync(transaction: transaction).Wait(); + } + } + } + + #endregion + + #endregion + + #region Update + + #region Update + + [TestMethod] + public void TestSqlTransactionForUpdateAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entity.ColumnBit = 0; + + // Act + connection.Update(entity, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Act + var queryResult = connection.Query(entity.Id); + + // Assert + Assert.AreEqual((ulong)0, queryResult.First().ColumnBit); + } + } + + [TestMethod] + public void TestSqlTransactionForUpdateAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entity.ColumnBit = 0; + + // Act + connection.Update(entity, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Act + var queryResult = connection.Query(entity.Id); + + // Assert + Assert.AreEqual((ulong)1, queryResult.First().ColumnBit); + } + } + + #endregion + + #region UpdateAsync + + [TestMethod] + public void TestSqlTransactionForUpdateAsyncAsCommitted() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entity.ColumnBit = 0; + + // Act + connection.UpdateAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Act + var queryResult = connection.Query(entity.Id); + + // Assert + Assert.AreEqual((ulong)0, queryResult.First().ColumnBit); + } + } + + [TestMethod] + public void TestSqlTransactionForUpdateAsyncAsRolledBack() + { + // Setup + var entity = Helper.CreateCompleteTables(1).First(); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.Insert(entity); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entity.ColumnBit = 0; + + // Act + connection.UpdateAsync(entity, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Act + var queryResult = connection.Query(entity.Id); + + // Assert + Assert.AreEqual((ulong)1, queryResult.First().ColumnBit); + } + } + + #endregion + + #endregion + + #region UpdateAll + + #region UpdateAll + + [TestMethod] + public void TestSqlTransactionForUpdateAllAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entities.ForEach(entity => entity.ColumnBit = 0); + + // Act + connection.UpdateAll(entities, transaction: transaction); + + // Act + transaction.Commit(); + } + + // Act + var queryResult = connection.QueryAll(); + + // Assert + entities.ForEach(entity => Assert.AreEqual((ulong)0, queryResult.First(item => item.Id == entity.Id).ColumnBit)); + } + } + + [TestMethod] + public void TestSqlTransactionForUpdateAllAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entities.ForEach(entity => entity.ColumnBit = 0); + + // Act + connection.UpdateAll(entities, transaction: transaction); + + // Act + transaction.Rollback(); + } + + // Act + var queryResult = connection.QueryAll(); + + // Assert + entities.ForEach(entity => Assert.AreEqual((ulong)1, queryResult.First(item => item.Id == entity.Id).ColumnBit)); + } + } + + #endregion + + #region UpdateAllAsync + + [TestMethod] + public void TestSqlTransactionForUpdateAllAsyncAsCommitted() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entities.ForEach(entity => entity.ColumnBit = 0); + + // Act + connection.UpdateAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Commit(); + } + + // Act + var queryResult = connection.QueryAll(); + + // Assert + entities.ForEach(entity => Assert.AreEqual((ulong)0, queryResult.First(item => item.Id == entity.Id).ColumnBit)); + } + } + + [TestMethod] + public void TestSqlTransactionForUpdateAllAsyncAsRolledBack() + { + // Setup + var entities = Helper.CreateCompleteTables(10); + + using (var connection = new MySqlConnection(Database.ConnectionString)) + { + // Act + connection.InsertAll(entities); + + // Prepare + using (var transaction = connection.EnsureOpen().BeginTransaction()) + { + entities.ForEach(entity => entity.ColumnBit = 0); + + // Act + connection.UpdateAllAsync(entities, transaction: transaction).Wait(); + + // Act + transaction.Rollback(); + } + + // Act + var queryResult = connection.QueryAll(); + + // Assert + entities.ForEach(entity => Assert.AreEqual((ulong)1, queryResult.First(item => item.Id == entity.Id).ColumnBit)); + } + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/appveyor.yml b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/appveyor.yml new file mode 100644 index 000000000..1fc73a30e --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.IntegrationTests/appveyor.yml @@ -0,0 +1,11 @@ +version: 1.0.{build} +image: Visual Studio 2017 +configuration: Release +platform: Any CPU +before_build: +- cmd: dotnet restore RepoDb.MySql\RepoDb.MySql.IntegrationTests\RepoDb.MySql.IntegrationTests.csproj +build: + project: RepoDb.MySql\RepoDb.MySql.IntegrationTests\RepoDb.MySql.IntegrationTests.csproj + verbosity: normal +services: + - mssql2017 \ No newline at end of file diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/DbSettingTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/DbSettingTest.cs new file mode 100644 index 000000000..70025c8cc --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/DbSettingTest.cs @@ -0,0 +1,125 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; + +namespace RepoDb.MySql.UnitTests +{ + [TestClass] + public class DbSettingTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + [TestMethod] + public void TestMySqlDbSettingAreTableHintsSupportedProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsFalse(setting.AreTableHintsSupported); + } + + [TestMethod] + public void TestMySqlDbSettingClosingQuoteProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.AreEqual("`", setting.ClosingQuote); + } + + [TestMethod] + public void TestMySqlDbSettingAverageableTypeProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.AreEqual(typeof(double), setting.AverageableType); + } + + [TestMethod] + public void TestMySqlDbSettingDefaultSchemaProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsNull(setting.DefaultSchema); + } + + [TestMethod] + public void TestMySqlDbSettingIsDirectionSupportedProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsFalse(setting.IsDirectionSupported); + } + + [TestMethod] + public void TestMySqlDbSettingIsExecuteReaderDisposableProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsFalse(setting.IsExecuteReaderDisposable); + } + + [TestMethod] + public void TestMySqlDbSettingIsMultiStatementExecutableProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsTrue(setting.IsMultiStatementExecutable); + } + + [TestMethod] + public void TestMySqlDbSettingIsUseUpsertProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsFalse(setting.IsUseUpsert); + } + + [TestMethod] + public void TestMySqlDbSettingOpeningQuoteProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.AreEqual("`", setting.OpeningQuote); + } + + [TestMethod] + public void TestMySqlDbSettingParameterPrefixProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.AreEqual("@", setting.ParameterPrefix); + } + + [TestMethod] + public void TestMySqlDbSettingSchemaSeparatorProperty() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.AreEqual(".", setting.SchemaSeparator); + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/MappingTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/MappingTest.cs new file mode 100644 index 000000000..80ff7431c --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/MappingTest.cs @@ -0,0 +1,45 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; + +namespace RepoDb.MySql.UnitTests +{ + [TestClass] + public class MappingTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + [TestMethod] + public void TestMySqlStatementBuilderMapper() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Assert + Assert.IsNotNull(builder); + } + + [TestMethod] + public void TestMySqlDbHelperMapper() + { + // Setup + var helper = DbHelperMapper.Get(); + + // Assert + Assert.IsNotNull(helper); + } + + [TestMethod] + public void TestMySqlDbSettingMapper() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Assert + Assert.IsNotNull(setting); + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/QuotationTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/QuotationTest.cs new file mode 100644 index 000000000..ff1c687b6 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/QuotationTest.cs @@ -0,0 +1,154 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Extensions; + +namespace RepoDb.MySql.UnitTests +{ + [TestClass] + public class QuotationTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + #region AsQuoted + + [TestMethod] + public void TestMySqlQuotationForQuotedAndTrimmed() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " Field ".AsQuoted(true, setting); + + // Assert + Assert.AreEqual("`Field`", result); + } + + [TestMethod] + public void TestMySqlQuotationForQuotedNonTrimmed() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " Field ".AsQuoted(setting); + + // Assert + Assert.AreEqual("` Field `", result); + } + + [TestMethod] + public void TestMySqlQuotationForQuotedForPreQuoted() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = "`Field`".AsQuoted(setting); + + // Assert + Assert.AreEqual("`Field`", result); + } + + [TestMethod] + public void TestMySqlQuotationForQuotedForPreQuotedWithSpace() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = "` Field `".AsQuoted(setting); + + // Assert + Assert.AreEqual("` Field `", result); + } + + [TestMethod] + public void TestMySqlQuotationForQuotedForPreQuotedWithSpaceAndTrimmed() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " ` Field ` ".AsQuoted(true, setting); + + // Assert + Assert.AreEqual("` Field `", result); + } + + #endregion + + #region AsUnquoted + + [TestMethod] + public void TestMySqlQuotationForUnquotedAndTrimmed() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " ` Field ` ".AsUnquoted(true, setting); + + // Assert + Assert.AreEqual("Field", result); + } + + [TestMethod] + public void TestMySqlQuotationForUnquotedNonTrimmed() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = "` Field `".AsUnquoted(setting); + + // Assert + Assert.AreEqual(" Field ", result); + } + + [TestMethod] + public void TestMySqlQuotationForUnquotedForPlain() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = "Field".AsUnquoted(setting); + + // Assert + Assert.AreEqual("Field", result); + } + + [TestMethod] + public void TestMySqlQuotationForUnquotedForPlainWithSpace() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " Field ".AsUnquoted(setting); + + // Assert + Assert.AreEqual(" Field ", result); + } + + [TestMethod] + public void TestMySqlQuotationForUnquotedAndTrimmedForPlainWithSpace() + { + // Setup + var setting = DbSettingMapper.Get(); + + // Act + var result = " Field ".AsUnquoted(true, setting); + + // Assert + Assert.AreEqual("Field", result); + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/RepoDb.MySql.UnitTests.csproj b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/RepoDb.MySql.UnitTests.csproj new file mode 100644 index 000000000..0f9137de8 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/RepoDb.MySql.UnitTests.csproj @@ -0,0 +1,19 @@ + + + + netcoreapp3.1 + + false + + + + + + + + + + + + + diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeNameToClientTypeResolverTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeNameToClientTypeResolverTest.cs new file mode 100644 index 000000000..2d1e6052e --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeNameToClientTypeResolverTest.cs @@ -0,0 +1,614 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using RepoDb.Resolvers; +using System; + +namespace RepoDb.MySql.UnitTests.Resolvers +{ + [TestClass] + public class MySqlDbTypeNameToClientTypeResolverTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBigInt() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BIGINT"); + + // Assert + Assert.AreEqual(typeof(long), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForInteger() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("INTEGER"); + + // Assert + Assert.AreEqual(typeof(long), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBlob() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BLOB"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBlobAsArray() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BLOBASARRAY"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBinary() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BINARY"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForLongBlob() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("LONGBLOB"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMediumBlob() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MEDIUMBLOB"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForTinyBlob() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TINYBLOB"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForVarBinary() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("VARBINARY"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForGeometry() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("GEOMETRY"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForLineString() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("LINESTRING"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMultiLineString() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MULTILINESTRING"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMultiPoint() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MULTIPOINT"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMultiPolygon() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MULTIPOLYGON"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForPoint() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("POINT"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForPolygon() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("POLYGON"); + + // Assert + Assert.AreEqual(typeof(byte[]), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBoolean() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BOOLEAN"); + + // Assert + Assert.AreEqual(typeof(bool), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForChar() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("CHAR"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForJson() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("JSON"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForLongText() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("LONGTEXT"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMediumText() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MEDIUMTEXT"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForNChar() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("NCHAR"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForNVarChar() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("NVARCHAR"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForString() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("STRING"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForText() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TEXT"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForTinyText() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TINYTEXT"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForVarChar() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("VARCHAR"); + + // Assert + Assert.AreEqual(typeof(string), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDate() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DATE"); + + // Assert + Assert.AreEqual(typeof(DateTime), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDateTime() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DATETIME"); + + // Assert + Assert.AreEqual(typeof(DateTime), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDateTime2() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DATETIME2"); + + // Assert + Assert.AreEqual(typeof(DateTime), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForTimeStamp() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TIMESTAMP"); + + // Assert + Assert.AreEqual(typeof(DateTime), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForTime() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TIME"); + + // Assert + Assert.AreEqual(typeof(TimeSpan), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDecimal() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DECIMAL"); + + // Assert + Assert.AreEqual(typeof(decimal), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDecimal2() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DECIMAL2"); + + // Assert + Assert.AreEqual(typeof(decimal), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForNumeric() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("NUMERIC"); + + // Assert + Assert.AreEqual(typeof(decimal), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForDouble() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("DOUBLE"); + + // Assert + Assert.AreEqual(typeof(double), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForReal() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("REAL"); + + // Assert + Assert.AreEqual(typeof(double), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForFloat() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("FLOAT"); + + // Assert + Assert.AreEqual(typeof(float), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForInt() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("INT"); + + // Assert + Assert.AreEqual(typeof(int), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForInt2() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("INT2"); + + // Assert + Assert.AreEqual(typeof(int), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForMediumInt() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("MEDIUMINT"); + + // Assert + Assert.AreEqual(typeof(int), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForYear() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("YEAR"); + + // Assert + Assert.AreEqual(typeof(int), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForSmallInt() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("SMALLINT"); + + // Assert + Assert.AreEqual(typeof(short), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForTinyInt() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("TINYINT"); + + // Assert + Assert.AreEqual(typeof(sbyte), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForBit() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("BIT"); + + // Assert + Assert.AreEqual(typeof(ulong), result); + } + + [TestMethod] + public void TestMySqlDbTypeNameToClientTypeResolverForNone() + { + // Setup + var resolver = new MySqlDbTypeNameToClientTypeResolver(); + + // Act + var result = resolver.Resolve("NONE"); + + // Assert + Assert.AreEqual(typeof(object), result); + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeToMySqlStringNameResolverTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeToMySqlStringNameResolverTest.cs new file mode 100644 index 000000000..2f0088bde --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/Resolvers/MySqlDbTypeToMySqlStringNameResolverTest.cs @@ -0,0 +1,523 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Resolvers; + +namespace RepoDb.MySql.UnitTests.Resolvers +{ + [TestClass] + public class MySqlDbTypeToMySqlStringNameResolverTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForBinary() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Binary); + + // Assert + Assert.AreEqual("BINARY", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForBit() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Bit); + + // Assert + Assert.AreEqual("BIT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForBlob() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Blob); + + // Assert + Assert.AreEqual("BLOB", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForByte() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Byte); + + // Assert + Assert.AreEqual("TINYINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForUByte() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.UByte); + + // Assert + Assert.AreEqual("TINYINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForDate() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Date); + + // Assert + Assert.AreEqual("DATE", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForDateTime() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.DateTime); + + // Assert + Assert.AreEqual("DATETIME", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForDecimal() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Decimal); + + // Assert + Assert.AreEqual("DECIMAL", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForDouble() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Double); + + // Assert + Assert.AreEqual("DOUBLE", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForEnum() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Enum); + + // Assert + Assert.AreEqual("TEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForGuid() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Guid); + + // Assert + Assert.AreEqual("TEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForSet() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Set); + + // Assert + Assert.AreEqual("TEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForText() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Text); + + // Assert + Assert.AreEqual("TEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForFloat() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Float); + + // Assert + Assert.AreEqual("FLOAT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForGeometry() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Geometry); + + // Assert + Assert.AreEqual("GEOMETRY", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForInt16() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Int16); + + // Assert + Assert.AreEqual("SMALLINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForInt24() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Int24); + + // Assert + Assert.AreEqual("SMALLINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForUInt24() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.UInt24); + + // Assert + Assert.AreEqual("SMALLINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForUInt16() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.UInt16); + + // Assert + Assert.AreEqual("SMALLINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForInt32() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Int32); + + // Assert + Assert.AreEqual("INT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForUInt32() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.UInt32); + + // Assert + Assert.AreEqual("INT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForInt64() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Int64); + + // Assert + Assert.AreEqual("BIGINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForUInt64() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.UInt64); + + // Assert + Assert.AreEqual("BIGINT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForJson() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.JSON); + + // Assert + Assert.AreEqual("JSON", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForLongBlob() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.LongBlob); + + // Assert + Assert.AreEqual("LONGBLOB", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForLongText() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.LongText); + + // Assert + Assert.AreEqual("LONGTEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForMediumBlob() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.MediumBlob); + + // Assert + Assert.AreEqual("MEDIUMBLOB", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForMediumText() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.MediumText); + + // Assert + Assert.AreEqual("MEDIUMTEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForNewdate() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Newdate); + + // Assert + Assert.AreEqual("DATE", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForNewDecimal() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.NewDecimal); + + // Assert + Assert.AreEqual("DECIMAL", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForString() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.String); + + // Assert + Assert.AreEqual("STRING", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForTime() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Time); + + // Assert + Assert.AreEqual("TIME", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForTimestamp() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Timestamp); + + // Assert + Assert.AreEqual("TIMESTAMP", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForTinyBlob() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.TinyBlob); + + // Assert + Assert.AreEqual("TINYBLOB", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForTinyText() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.TinyText); + + // Assert + Assert.AreEqual("TINYTEXT", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForVarBinary() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.VarBinary); + + // Assert + Assert.AreEqual("VARBINARY", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForVarChar() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.VarChar); + + // Assert + Assert.AreEqual("VARCHAR", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForVarString() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.VarString); + + // Assert + Assert.AreEqual("VARCHAR", result); + } + + [TestMethod] + public void TestMySqlDbTypeToMySqlStringNameResolverForYear() + { + // Setup + var resolver = new MySqlDbTypeToMySqlStringNameResolver(); + + // Act + var result = resolver.Resolve(MySqlDbType.Year); + + // Assert + Assert.AreEqual("YEAR", result); + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/StatementBuilderTest.cs b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/StatementBuilderTest.cs new file mode 100644 index 000000000..f15dd0bf8 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.UnitTests/StatementBuilderTest.cs @@ -0,0 +1,1116 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using MySql.Data.MySqlClient; +using RepoDb.Enumerations; +using RepoDb.Exceptions; +using System; + +namespace RepoDb.MySql.UnitTests +{ + [TestClass] + public class StatementBuilderTest + { + [TestInitialize] + public void Initialize() + { + MySqlBootstrap.Initialize(); + } + + #region CreateBatchQuery + + [TestMethod] + public void TestMySqlStatementBuilderCreateBatchQuery() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + 0, + 10, + OrderField.Parse(new { Id = Order.Ascending })); + var expected = "SELECT `Id`, `Name` FROM `Table` ORDER BY `Id` ASC LIMIT 10 ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateBatchQueryWithPage() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + 3, + 10, + OrderField.Parse(new { Id = Order.Ascending })); + var expected = "SELECT `Id`, `Name` FROM `Table` ORDER BY `Id` ASC LIMIT 30, 10 ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NullReferenceException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateBatchQueryIfThereAreNoFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateBatchQuery(new QueryBuilder(), + "Table", + null, + 0, + 10, + OrderField.Parse(new { Id = Order.Ascending })); + } + + [TestMethod, ExpectedException(typeof(EmptyException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateBatchQueryIfThereAreNoOrderFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + 0, + 10, + null); + } + + [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateBatchQueryIfThePageValueIsNullOrOutOfRange() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + -1, + 10, + OrderField.Parse(new { Id = Order.Ascending })); + } + + [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateBatchQueryIfTheRowsPerBatchValueIsNullOrOutOfRange() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + 0, + -1, + OrderField.Parse(new { Id = Order.Ascending })); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateBatchQueryIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateBatchQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name"), + 0, + -1, + OrderField.Parse(new { Id = Order.Ascending }), + null, + "WhatEver"); + } + + #endregion + + #region CreateCount + + [TestMethod] + public void TestMySqlStatementBuilderCreateCount() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateCount(new QueryBuilder(), + "Table", + null, + null); + var expected = "SELECT COUNT(*) AS `CountValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateCountWithExpression() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateCount(new QueryBuilder(), + "Table", + QueryGroup.Parse(new { Id = 1 }), + null); + var expected = "SELECT COUNT(*) AS `CountValue` FROM `Table` WHERE (`Id` = @Id) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateCountIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateCount(new QueryBuilder(), + "Table", + QueryGroup.Parse(new { Id = 1 }), + "WhatEver"); + } + + #endregion + + #region CreateCountAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateCountAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateCountAll(new QueryBuilder(), + "Table", + null); + var expected = "SELECT COUNT(*) AS `CountValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateCountAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateCountAll(new QueryBuilder(), + "Table", + "WhatEver"); + } + + #endregion + + #region CreateExists + + [TestMethod] + public void TestMySqlStatementBuilderCreateExists() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateExists(new QueryBuilder(), + "Table", + QueryGroup.Parse(new { Id = 1 })); + var expected = "SELECT 1 AS `ExistsValue` FROM `Table` WHERE (`Id` = @Id) LIMIT 1 ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + #endregion + + #region CreateInsert + + [TestMethod] + public void TestMySqlStatementBuilderCreateInsert() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsert(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ; SELECT NULL AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateInsertWithPrimary() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsert(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ; SELECT @Id AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateInsertWithIdentity() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsert(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + new DbField("Id", false, true, false, typeof(int), null, null, null, null)); + var expected = "INSERT INTO `Table` ( `Name`, `Address` ) VALUES ( @Name, @Address ) ; SELECT LAST_INSERT_ID() AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateInsertIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateInsert(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + new DbField("Id", false, true, false, typeof(int), null, null, null, null), + "WhatEver"); + } + + #endregion + + #region CreateInsertAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateInsertAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsertAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + 3, + null, + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_1, @Name_1, @Address_1 ) ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_2, @Name_2, @Address_2 ) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateInserAlltWithPrimary() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsertAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_1, @Name_1, @Address_1 ) ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_2, @Name_2, @Address_2 ) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateInsertAllWithIdentity() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateInsertAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + 3, + null, + new DbField("Id", false, true, false, typeof(int), null, null, null, null)); + var expected = "INSERT INTO `Table` ( `Name`, `Address` ) VALUES ( @Name, @Address ) ; SELECT LAST_INSERT_ID() ; " + + "INSERT INTO `Table` ( `Name`, `Address` ) VALUES ( @Name_1, @Address_1 ) ; SELECT LAST_INSERT_ID() ; " + + "INSERT INTO `Table` ( `Name`, `Address` ) VALUES ( @Name_2, @Address_2 ) ; SELECT LAST_INSERT_ID() ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateInsertAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateInsertAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + 3, + null, + new DbField("Id", false, true, false, typeof(int), null, null, null, null), + "WhatEver"); + } + + #endregion + + #region CreateMax + + [TestMethod] + public void TestMySqlStatementBuilderCreateMax() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMax(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null, + null); + var expected = "SELECT MAX(`Field`) AS `MaxValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMaxWithExpression() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMax(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + null); + var expected = "SELECT MAX(`Field`) AS `MaxValue` FROM `Table` WHERE (`Id` = @Id) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMaxIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMax(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + "WhatEver"); + } + + #endregion + + #region CreateMaxAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateMaxAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMaxAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null); + var expected = "SELECT MAX(`Field`) AS `MaxValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMaxAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMaxAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + "WhatEver"); + } + + #endregion + + #region CreateMin + + [TestMethod] + public void TestMySqlStatementBuilderCreateMin() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMin(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null, + null); + var expected = "SELECT MIN(`Field`) AS `MinValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMinWithExpression() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMin(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + null); + var expected = "SELECT MIN(`Field`) AS `MinValue` FROM `Table` WHERE (`Id` = @Id) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMinIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMin(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + "WhatEver"); + } + + #endregion + + #region CreateMinAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateMinAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMinAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null); + var expected = "SELECT MIN(`Field`) AS `MinValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMinAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMinAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + "WhatEver"); + } + + #endregion + + #region CreateMerge + + [TestMethod] + public void TestMySqlStatementBuilderCreateMerge() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY " + + "UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMergeWithPrimaryAsQualifier() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id"), + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY " + + "UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMergeWithIdentity() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + new DbField("Id", false, true, false, typeof(int), null, null, null, null)); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY " + + "UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(PrimaryFieldNotFoundException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeIfThereIsNoPrimary() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null, + null); + } + + [TestMethod, ExpectedException(typeof(PrimaryFieldNotFoundException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeIfThereAreNoFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null, + null); + } + + [TestMethod, ExpectedException(typeof(InvalidQualifiersException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeIfThereAreOtherFieldsAsQualifers() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id", "Name"), + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMerge(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id", "Name"), + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null, + "WhatEver"); + } + + #endregion + + #region CreateMergeAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateMergeAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_1, @Name_1, @Address_1 ) ON DUPLICATE KEY UPDATE `Id` = @Id_1, `Name` = @Name_1, `Address` = @Address_1 ; SELECT COALESCE(@Id_1, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_2, @Name_2, @Address_2 ) ON DUPLICATE KEY UPDATE `Id` = @Id_2, `Name` = @Name_2, `Address` = @Address_2 ; SELECT COALESCE(@Id_2, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMergeAllWithPrimaryAsQualifier() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id"), + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_1, @Name_1, @Address_1 ) ON DUPLICATE KEY UPDATE `Id` = @Id_1, `Name` = @Name_1, `Address` = @Address_1 ; SELECT COALESCE(@Id_1, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_2, @Name_2, @Address_2 ) ON DUPLICATE KEY UPDATE `Id` = @Id_2, `Name` = @Name_2, `Address` = @Address_2 ; SELECT COALESCE(@Id_2, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateMergeAllWithIdentity() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + new DbField("Id", false, true, false, typeof(int), null, null, null, null)); + var expected = "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id, @Name, @Address ) ON DUPLICATE KEY UPDATE `Id` = @Id, `Name` = @Name, `Address` = @Address ; SELECT COALESCE(@Id, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_1, @Name_1, @Address_1 ) ON DUPLICATE KEY UPDATE `Id` = @Id_1, `Name` = @Name_1, `Address` = @Address_1 ; SELECT COALESCE(@Id_1, LAST_INSERT_ID()) AS `Result` ; " + + "INSERT INTO `Table` ( `Id`, `Name`, `Address` ) VALUES ( @Id_2, @Name_2, @Address_2 ) ON DUPLICATE KEY UPDATE `Id` = @Id_2, `Name` = @Name_2, `Address` = @Address_2 ; SELECT COALESCE(@Id_2, LAST_INSERT_ID()) AS `Result` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(PrimaryFieldNotFoundException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeAllIfThereIsNoPrimary() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + 3, + null, + null); + } + + [TestMethod, ExpectedException(typeof(PrimaryFieldNotFoundException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeAllIfThereAreNoFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + 3, + null, + null); + } + + [TestMethod, ExpectedException(typeof(InvalidQualifiersException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeAllIfThereAreOtherFieldsAsQualifers() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id", "Name"), + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateMergeAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateMergeAll(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + Field.From("Id", "Name"), + 3, + new DbField("Id", true, false, false, typeof(int), null, null, null, null), + null, + "WhatEver"); + } + + #endregion + + #region CreateQuery + + [TestMethod] + public void TestMySqlStatementBuilderCreateQuery() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null, + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryWithExpression() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + QueryGroup.Parse(new { Id = 1, Name = "Michael" }), + null, + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` WHERE (`Id` = @Id AND `Name` = @Name) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryWithTop() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null, + 10, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` LIMIT 10 ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryOrderBy() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Ascending }), + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ORDER BY `Id` ASC ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryOrderByFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Ascending, Name = Order.Ascending }), + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ORDER BY `Id` ASC, `Name` ASC ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryOrderByDescending() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Descending }), + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ORDER BY `Id` DESC ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryOrderByFieldsDescending() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Descending, Name = Order.Descending }), + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ORDER BY `Id` DESC, `Name` DESC ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateQueryOrderByFieldsMultiDirection() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Ascending, Name = Order.Descending }), + null, + null); + var expected = "SELECT `Id`, `Name`, `Address` FROM `Table` ORDER BY `Id` ASC, `Name` DESC ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(MissingFieldsException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateQueryIfOrderFieldsAreNotPresentAtTheFields() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + OrderField.Parse(new { Id = Order.Descending, SSN = Order.Ascending }), + null, + null); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateQueryIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateQuery(new QueryBuilder(), + "Table", + Field.From("Id", "Name", "Address"), + null, + null, + null, + "WhatEver"); + } + + #endregion + + #region CreateSum + + [TestMethod] + public void TestMySqlStatementBuilderCreateSum() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateSum(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null, + null); + var expected = "SELECT SUM(`Field`) AS `SumValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod] + public void TestMySqlStatementBuilderCreateSumWithExpression() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateSum(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + null); + var expected = "SELECT SUM(`Field`) AS `SumValue` FROM `Table` WHERE (`Id` = @Id) ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateSumIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateSum(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + QueryGroup.Parse(new { Id = 1 }), + "WhatEver"); + } + + #endregion + + #region CreateSumAll + + [TestMethod] + public void TestMySqlStatementBuilderCreateSumAll() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + var query = builder.CreateSumAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + null); + var expected = "SELECT SUM(`Field`) AS `SumValue` FROM `Table` ;"; + + // Assert + Assert.AreEqual(expected, query); + } + + [TestMethod, ExpectedException(typeof(NotSupportedException))] + public void ThrowExceptionOnMySqlStatementBuilderCreateSumAllIfThereAreHints() + { + // Setup + var builder = StatementBuilderMapper.Get(); + + // Act + builder.CreateSumAll(new QueryBuilder(), + "Table", + new Field("Field", typeof(int)), + "WhatEver"); + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql.sln b/RepoDb.MySqlConnector/RepoDb.MySql.sln new file mode 100644 index 000000000..449441106 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql.sln @@ -0,0 +1,54 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.27703.2042 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoDb.MySql", "RepoDb.MySql\RepoDb.MySql.csproj", "{8666BE62-EB29-4FF7-8F7D-E1704720E5E8}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "RepoDb.MySql.Tests", "RepoDb.MySql.Tests", "{BC604FB6-F172-46DC-B0D4-852DB7E1E819}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoDb.MySql.IntegrationTests", "RepoDb.MySql.IntegrationTests\RepoDb.MySql.IntegrationTests.csproj", "{3C9481E3-0E7E-44C4-9728-A84B03398FC7}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoDb.MySql.UnitTests", "RepoDb.MySql.UnitTests\RepoDb.MySql.UnitTests.csproj", "{B42BA57C-B9AE-42BD-97FC-D3346BA6166A}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoDb", "..\RepoDb.Core\RepoDb\RepoDb.csproj", "{5B81E622-71C1-4A8D-9019-2CBE95EC7088}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "RepoDb.MySql.Base", "RepoDb.MySql.Base", "{1CEC5132-0304-4A8A-93EB-79151DDFF200}" + ProjectSection(SolutionItems) = preProject + README.md = README.md + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {8666BE62-EB29-4FF7-8F7D-E1704720E5E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8666BE62-EB29-4FF7-8F7D-E1704720E5E8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8666BE62-EB29-4FF7-8F7D-E1704720E5E8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8666BE62-EB29-4FF7-8F7D-E1704720E5E8}.Release|Any CPU.Build.0 = Release|Any CPU + {3C9481E3-0E7E-44C4-9728-A84B03398FC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3C9481E3-0E7E-44C4-9728-A84B03398FC7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3C9481E3-0E7E-44C4-9728-A84B03398FC7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3C9481E3-0E7E-44C4-9728-A84B03398FC7}.Release|Any CPU.Build.0 = Release|Any CPU + {B42BA57C-B9AE-42BD-97FC-D3346BA6166A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B42BA57C-B9AE-42BD-97FC-D3346BA6166A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B42BA57C-B9AE-42BD-97FC-D3346BA6166A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B42BA57C-B9AE-42BD-97FC-D3346BA6166A}.Release|Any CPU.Build.0 = Release|Any CPU + {5B81E622-71C1-4A8D-9019-2CBE95EC7088}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5B81E622-71C1-4A8D-9019-2CBE95EC7088}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5B81E622-71C1-4A8D-9019-2CBE95EC7088}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5B81E622-71C1-4A8D-9019-2CBE95EC7088}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {3C9481E3-0E7E-44C4-9728-A84B03398FC7} = {BC604FB6-F172-46DC-B0D4-852DB7E1E819} + {B42BA57C-B9AE-42BD-97FC-D3346BA6166A} = {BC604FB6-F172-46DC-B0D4-852DB7E1E819} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {5A29F8AC-5A80-4123-82C6-1BA1EDF67073} + EndGlobalSection +EndGlobal diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/Attributes/MySqlTypeMapAttribute.cs b/RepoDb.MySqlConnector/RepoDb.MySql/Attributes/MySqlTypeMapAttribute.cs new file mode 100644 index 000000000..2c2af49dc --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/Attributes/MySqlTypeMapAttribute.cs @@ -0,0 +1,31 @@ +using MySql.Data.MySqlClient; +using System; + +namespace RepoDb.Attributes +{ + /// + /// An attribute used to define a mapping of .NET CLR into its equivalent value. + /// + public class MySqlTypeMapAttribute : Attribute + { + /// + /// Creates a new instance of class. + /// + /// A target value. + public MySqlTypeMapAttribute(MySqlDbType dbType) + { + DbType = dbType; + ParameterType = typeof(MySqlParameter); + } + + /// + /// Gets a that is currently mapped. + /// + public MySqlDbType DbType { get; } + + /// + /// Gets the represented of the . + /// + public Type ParameterType { get; } + } +} \ No newline at end of file diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/DbHelpers/MySqlDbHelper.cs b/RepoDb.MySqlConnector/RepoDb.MySql/DbHelpers/MySqlDbHelper.cs new file mode 100644 index 000000000..d23c66aa1 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/DbHelpers/MySqlDbHelper.cs @@ -0,0 +1,261 @@ +using MySql.Data.MySqlClient; +using RepoDb.Extensions; +using RepoDb.Interfaces; +using RepoDb.Resolvers; +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Threading.Tasks; + +namespace RepoDb.DbHelpers +{ + /// + /// A helper class for database specially for the direct access. This class is only meant for MySql. + /// + public sealed class MySqlDbHelper : IDbHelper + { + private IDbSetting m_dbSetting = DbSettingMapper.Get(); + + /// + /// Creates a new instance of class. + /// + public MySqlDbHelper() + : this(new MySqlDbTypeNameToClientTypeResolver()) + { } + + /// + /// Creates a new instance of class. + /// + /// The type resolver to be used. + public MySqlDbHelper(IResolver dbTypeResolver) + { + DbTypeResolver = dbTypeResolver; + } + + #region Properties + + /// + /// Gets the type resolver used by this instance. + /// + public IResolver DbTypeResolver { get; } + + #endregion + + #region Helpers + + /// + /// Returns the command text that is being used to extract schema definitions. + /// + /// The command text. + private string GetCommandText() + { + return $@"SELECT COLUMN_NAME AS ColumnName + , CASE WHEN COLUMN_KEY = 'PRI' THEN 1 ELSE 0 END AS IsPrimary + , CASE WHEN EXTRA LIKE '%auto_increment%' THEN 1 ELSE 0 END AS IsIdentity + , CASE WHEN IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS IsNullable + , DATA_TYPE AS ColumnType /*COLUMN_TYPE AS ColumnType*/ + , CHARACTER_MAXIMUM_LENGTH AS Size + , COALESCE(NUMERIC_PRECISION, DATETIME_PRECISION) AS `Precision` + , NUMERIC_SCALE AS Scale + , DATA_TYPE AS DatabaseType + FROM INFORMATION_SCHEMA.COLUMNS + WHERE TABLE_SCHEMA = @TableSchema + AND TABLE_NAME = @TableName + ORDER BY ORDINAL_POSITION;"; + } + + /// + /// Get the list of type names for all blob-types for MySql. + /// + /// The list of column type names. + private IEnumerable GetBlobTypes() + { + return new[] + { + "blob", + "blobasarray", + "binary", + "longtext", + "mediumtext", + "longblob", + "mediumblob", + "tinyblob", + "varbinary" + }; + } + + /// + /// Converts the object into object. + /// + /// The instance of object. + /// The instance of converted object. + private DbField ReaderToDbField(IDataReader reader) + { + var columnType = reader.GetString(4); + var excluded = GetBlobTypes(); + var size = (int?)null; + if (excluded.Contains(columnType.ToLower())) + { + size = null; + } + else + { + size = reader.IsDBNull(5) ? (int?)null : reader.GetInt32(5); + } + return new DbField(reader.GetString(0), + reader.GetBoolean(1), + reader.GetBoolean(2), + reader.GetBoolean(3), + DbTypeResolver.Resolve(columnType), + size, + reader.IsDBNull(6) ? (byte?)null : byte.Parse(reader.GetInt32(6).ToString()), + reader.IsDBNull(7) ? (byte?)null : byte.Parse(reader.GetInt32(7).ToString()), + reader.GetString(8)); + } + + /// + /// Gets the actual schema of the table from the database. + /// + /// The passed table name. + /// The actual table schema. + private string GetSchema(string tableName) + { + // Get the schema and table name + if (tableName.IndexOf(m_dbSetting.SchemaSeparator) > 0) + { + var splitted = tableName.Split(m_dbSetting.SchemaSeparator.ToCharArray()); + return splitted[0].AsUnquoted(true, m_dbSetting); + } + + // Return the unquoted + return m_dbSetting.DefaultSchema; + } + + /// + /// Gets the actual name of the table from the database. + /// + /// The passed table name. + /// The actual table name. + private string GetTableName(string tableName) + { + // Get the schema and table name + if (tableName.IndexOf(m_dbSetting.SchemaSeparator) > 0) + { + var splitted = tableName.Split(m_dbSetting.SchemaSeparator.ToCharArray()); + return splitted[1].AsUnquoted(true, m_dbSetting); + } + + // Return the unquoted + return tableName.AsUnquoted(true, m_dbSetting); + } + + #endregion + + #region Methods + + #region GetFields + + /// + /// Gets the list of of the table. + /// + /// The instance of the connection object. + /// The name of the target table. + /// The transaction object that is currently in used. + /// A list of of the target table. + public IEnumerable GetFields(IDbConnection connection, + string tableName, + IDbTransaction transaction = null) + { + // Variables + var commandText = GetCommandText(); + var param = new + { + TableSchema = connection.Database, + TableName = GetTableName(tableName) + }; + + // Iterate and extract + using (var reader = connection.ExecuteReader(commandText, param, transaction: transaction)) + { + var dbFields = new List(); + + // Iterate the list of the fields + while (reader.Read()) + { + dbFields.Add(ReaderToDbField(reader)); + } + + // Return the list of fields + return dbFields; + } + } + + /// + /// Gets the list of of the table in an asychronous way. + /// + /// The instance of the connection object. + /// The name of the target table. + /// The transaction object that is currently in used. + /// A list of of the target table. + public async Task> GetFieldsAsync(IDbConnection connection, + string tableName, + IDbTransaction transaction = null) + { + // Variables + var commandText = GetCommandText(); + var param = new + { + TableSchema = connection.Database, + TableName = GetTableName(tableName) + }; + + // Iterate and extract + using (var reader = await connection.ExecuteReaderAsync(commandText, param, transaction: transaction)) + { + var dbFields = new List(); + + // Iterate the list of the fields + while (reader.Read()) + { + dbFields.Add(ReaderToDbField(reader)); + } + + // Return the list of fields + return dbFields; + } + } + + #endregion + + #region GetScopeIdentity + + /// + /// Gets the newly generated identity from the database. + /// + /// The instance of the connection object. + /// The transaction object that is currently in used. + /// The newly generated identity from the database. + public object GetScopeIdentity(IDbConnection connection, + IDbTransaction transaction = null) + { + return connection.ExecuteScalar("SELECT LAST_INSERT_ID();"); + } + + /// + /// Gets the newly generated identity from the database in an asychronous way. + /// + /// The instance of the connection object. + /// The transaction object that is currently in used. + /// The newly generated identity from the database. + public async Task GetScopeIdentityAsync(IDbConnection connection, + IDbTransaction transaction = null) + { + return await connection.ExecuteScalarAsync("SELECT LAST_INSERT_ID();"); + } + + #endregion + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/DbSettings/MySqlDbSetting.cs b/RepoDb.MySqlConnector/RepoDb.MySql/DbSettings/MySqlDbSetting.cs new file mode 100644 index 000000000..ec6638f19 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/DbSettings/MySqlDbSetting.cs @@ -0,0 +1,30 @@ +using MySql.Data.MySqlClient; +using RepoDb.DbSettings; + +namespace RepoDb.MySql.DbSettings +{ + /// + /// A setting class used for data provider. + /// + public sealed class MySqlDbSetting : BaseDbSetting + { + /// + /// Creates a new instance of class. + /// + public MySqlDbSetting() + { + AreTableHintsSupported = false; + AverageableType = typeof(double); + ClosingQuote = "`"; + DefaultSchema = null; + IsDirectionSupported = false; + IsExecuteReaderDisposable = false; + IsMultiStatementExecutable = true; + IsPreparable = true; + IsUseUpsert = false; + OpeningQuote = "`"; + ParameterPrefix = "@"; + SchemaSeparator = "."; + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/MySqlBootstrap.cs b/RepoDb.MySqlConnector/RepoDb.MySql/MySqlBootstrap.cs new file mode 100644 index 000000000..e2d1b424e --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/MySqlBootstrap.cs @@ -0,0 +1,50 @@ +using MySql.Data.MySqlClient; +using RepoDb.DbHelpers; +using RepoDb.MySql.DbSettings; +using RepoDb.StatementBuilders; + +namespace RepoDb +{ + /// + /// A class used to initialize necessary objects that is connected to object. + /// + public static class MySqlBootstrap + { + #region Properties + + /// + /// Gets the value indicating whether the initialization is completed. + /// + public static bool IsInitialized { get; private set; } + + #endregion + + #region Methods + + /// + /// Initializes all necessary settings for MySql. + /// + public static void Initialize() + { + // Skip if already initialized + if (IsInitialized == true) + { + return; + } + + // Map the DbSetting + DbSettingMapper.Add(typeof(MySqlConnection), new MySqlDbSetting(), true); + + // Map the DbHelper + DbHelperMapper.Add(typeof(MySqlConnection), new MySqlDbHelper(), true); + + // Map the Statement Builder + StatementBuilderMapper.Add(typeof(MySqlConnection), new MySqlStatementBuilder(), true); + + // Set the flag + IsInitialized = true; + } + + #endregion + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/RepoDb.MySql.csproj b/RepoDb.MySqlConnector/RepoDb.MySql/RepoDb.MySql.csproj new file mode 100644 index 000000000..acc402cee --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/RepoDb.MySql.csproj @@ -0,0 +1,66 @@ + + + + netstandard2.0 + Michael Camara Pendon + 1.0.11 + RepoDb + RepoDb + A hybrid .NET ORM library for MySql. + Copyright © 2020 + + http://repodb.net/ + https://github.com/mikependon/RepoDb/tree/master/RepoDb.MySql + Github + orm orm-framework orm-library hybrid-orm mysql mysql-orm + http://repodb.net/release/mysql + True + False + 1.0.11.0 + 1.0.11.0 + + + RepoDb-64x64.png + LICENSE.txt + + + + bin\Release\netstandard2.0\RepoDb.MySql.xml + + + + TRACE;DEBUG;NETSTANDARD;NETSTANDARD2_0 + false + false + bin\Debug\netstandard2.0\RepoDb.MySql.xml + + + + + + + + + + + + + + + + + + + + + + True + + + + True + + + + + diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeNameToClientTypeResolver.cs b/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeNameToClientTypeResolver.cs new file mode 100644 index 000000000..cc62d2d3b --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeNameToClientTypeResolver.cs @@ -0,0 +1,133 @@ +using RepoDb.Interfaces; +using System; + +namespace RepoDb.Resolvers +{ + /// + /// A class used to resolve the MySql Database Types into its equivalent .NET CLR Types. + /// + public class MySqlDbTypeNameToClientTypeResolver : IResolver + { + /// + /// Returns the equivalent .NET CLR Types of the Database Type. + /// + /// The name of the database type. + /// The equivalent .NET CLR type. + public virtual Type Resolve(string dbTypeName) + { + if (dbTypeName == null) + { + throw new NullReferenceException("The DB Type name must not be null."); + } + /* + Id (System.Int64) + ColumnVarchar (System.String) + ColumnInt (System.Int32) + ColumnDecimal2 (System.Decimal) + ColumnDateTime (System.DateTime) + ColumnBlob (System.Byte[]) + ColumnBlobAsArray (System.Byte[]) + ColumnBinary (System.Byte[]) + ColumnLongBlob (System.Byte[]) + ColumnMediumBlob (System.Byte[]) + ColumnTinyBlob (System.Byte[]) + ColumnVarBinary (System.Byte[]) + ColumnDate (System.DateTime) + ColumnDateTime2 (System.DateTime) + ColumnTime (System.TimeSpan) + ColumnTimeStamp (System.DateTime) + ColumnYear (System.Int16) + ColumnGeometry (System.Byte[]) + ColumnLineString (System.Byte[]) + ColumnMultiLineString (System.Byte[]) + ColumnMultiPoint (System.Byte[]) + ColumnMultiPolygon (System.Byte[]) + ColumnPoint (System.Byte[]) + ColumnPolygon (System.Byte[]) + ColumnBigint (System.Int64) + ColumnDecimal (System.Decimal) + ColumnDouble (System.Double) + ColumnFloat (System.Single) + ColumnInt2 (System.Int32) + ColumnMediumInt (System.Int32) + ColumnReal (System.Double) + ColumnSmallInt (System.Int16) + ColumnTinyInt (System.SByte) + ColumnChar (System.String) + ColumnJson (System.String) + ColumnNChar (System.String) + ColumnNVarChar (System.String) + ColumnLongText (System.String) + ColumnMediumText (System.String) + ColumText (System.String) + ColumnTinyText (System.String) + ColumnBit (System.UInt64) + */ + switch (dbTypeName.ToLower()) + { + case "bigint": + case "integer": + return typeof(long); + case "blob": + case "blobasarray": + case "binary": + case "longblob": + case "mediumblob": + case "tinyblob": + case "varbinary": + case "geometry": + case "linestring": + case "multilinestring": + case "multipoint": + case "multipolygon": + case "point": + case "polygon": + return typeof(byte[]); + case "boolean": + return typeof(bool); + case "char": + case "json": + case "longtext": + case "mediumtext": + case "nchar": + case "nvarchar": + case "string": + case "text": + case "tinytext": + case "varchar": + return typeof(string); + case "date": + case "datetime": + case "datetime2": + case "timestamp": + return typeof(DateTime); + case "time": + return typeof(TimeSpan); + case "decimal": + case "decimal2": + case "numeric": + return typeof(decimal); + case "double": + case "real": + return typeof(double); + case "float": + return typeof(float); + case "int": + case "int2": + case "mediumint": + case "year": + return typeof(int); + case "smallint": + return typeof(short); + case "tinyint": + return typeof(sbyte); + case "bit": + return typeof(ulong); + case "none": + return typeof(object); + default: + return typeof(object); + } + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeToMySqlStringNameResolver.cs b/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeToMySqlStringNameResolver.cs new file mode 100644 index 000000000..6a1830020 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/Resolvers/MySqlDbTypeToMySqlStringNameResolver.cs @@ -0,0 +1,139 @@ +using MySql.Data.MySqlClient; +using RepoDb.Interfaces; +using System.Data; + +namespace RepoDb.Resolvers +{ + /// + /// A class used to resolve the into its equivalent database string name. + /// + public class MySqlDbTypeToMySqlStringNameResolver : IResolver + { + /// + /// Returns the equivalent of the .NET CLR Types. + /// + /// The type of the database. + /// The equivalent string name. + public virtual string Resolve(MySqlDbType dbType) + { + /* + Id (System.Int64) + ColumnVarchar (System.String) + ColumnInt (System.Int32) + ColumnDecimal2 (System.Decimal) + ColumnDateTime (System.DateTime) + ColumnBlob (System.Byte[]) + ColumnBlobAsArray (System.Byte[]) + ColumnBinary (System.Byte[]) + ColumnLongBlob (System.Byte[]) + ColumnMediumBlob (System.Byte[]) + ColumnTinyBlob (System.Byte[]) + ColumnVarBinary (System.Byte[]) + ColumnDate (System.DateTime) + ColumnDateTime2 (System.DateTime) + ColumnTime (System.TimeSpan) + ColumnTimeStamp (System.DateTime) + ColumnYear (System.Int16) + ColumnGeometry (System.Byte[]) + ColumnLineString (System.Byte[]) + ColumnMultiLineString (System.Byte[]) + ColumnMultiPoint (System.Byte[]) + ColumnMultiPolygon (System.Byte[]) + ColumnPoint (System.Byte[]) + ColumnPolygon (System.Byte[]) + ColumnBigint (System.Int64) + ColumnDecimal (System.Decimal) + ColumnDouble (System.Double) + ColumnFloat (System.Single) + ColumnInt2 (System.Int32) + ColumnMediumInt (System.Int32) + ColumnReal (System.Double) + ColumnSmallInt (System.Int16) + ColumnTinyInt (System.SByte) + ColumnChar (System.String) + ColumnJson (System.String) + ColumnNChar (System.String) + ColumnNVarChar (System.String) + ColumnLongText (System.String) + ColumnMediumText (System.String) + ColumText (System.String) + ColumnTinyText (System.String) + ColumnBit (System.UInt64) + */ + switch (dbType) + { + case MySqlDbType.Binary: + return "BINARY"; + case MySqlDbType.Bit: + return "BIT"; + case MySqlDbType.Blob: + return "BLOB"; + case MySqlDbType.Byte: + case MySqlDbType.UByte: + return "TINYINT"; + case MySqlDbType.Date: + return "DATE"; + case MySqlDbType.DateTime: + return "DATETIME"; + case MySqlDbType.Decimal: + return "DECIMAL"; + case MySqlDbType.Double: + return "DOUBLE"; + case MySqlDbType.Enum: + case MySqlDbType.Guid: + case MySqlDbType.Set: + case MySqlDbType.Text: + return "TEXT"; + case MySqlDbType.Float: + return "FLOAT"; + case MySqlDbType.Geometry: + return "GEOMETRY"; + case MySqlDbType.Int16: + case MySqlDbType.Int24: + case MySqlDbType.UInt24: + case MySqlDbType.UInt16: + return "SMALLINT"; + case MySqlDbType.Int32: + case MySqlDbType.UInt32: + return "INT"; + case MySqlDbType.Int64: + case MySqlDbType.UInt64: + return "BIGINT"; + case MySqlDbType.JSON: + return "JSON"; + case MySqlDbType.LongBlob: + return "LONGBLOB"; + case MySqlDbType.LongText: + return "LONGTEXT"; + case MySqlDbType.MediumBlob: + return "MEDIUMBLOB"; + case MySqlDbType.MediumText: + return "MEDIUMTEXT"; + case MySqlDbType.Newdate: + return "DATE"; + case MySqlDbType.NewDecimal: + return "DECIMAL"; + case MySqlDbType.String: + return "STRING"; + case MySqlDbType.Time: + return "TIME"; + case MySqlDbType.Timestamp: + return "TIMESTAMP"; + case MySqlDbType.TinyBlob: + return "TINYBLOB"; + case MySqlDbType.TinyText: + return "TINYTEXT"; + case MySqlDbType.VarBinary: + return "VARBINARY"; + case MySqlDbType.VarChar: + return "VARCHAR"; + case MySqlDbType.VarString: + return "VARCHAR"; + case MySqlDbType.Year: + return "YEAR"; + default: + return "TEXT"; + } + } + } +} diff --git a/RepoDb.MySqlConnector/RepoDb.MySql/StatementBuilders/MySqlStatementBuilder.cs b/RepoDb.MySqlConnector/RepoDb.MySql/StatementBuilders/MySqlStatementBuilder.cs new file mode 100644 index 000000000..de0ee0235 --- /dev/null +++ b/RepoDb.MySqlConnector/RepoDb.MySql/StatementBuilders/MySqlStatementBuilder.cs @@ -0,0 +1,758 @@ +using MySql.Data.MySqlClient; +using RepoDb.Exceptions; +using RepoDb.Extensions; +using RepoDb.Interfaces; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace RepoDb.StatementBuilders +{ + /// + /// A class used to build a SQL Statement for MySql. + /// + public sealed class MySqlStatementBuilder : BaseStatementBuilder + { + /// + /// Creates a new instance of object. + /// + public MySqlStatementBuilder() + : this(DbSettingMapper.Get(typeof(MySqlConnection)), + null, + null) + { } + + /// + /// Creates a new instance of class. + /// + /// The database settings object currently in used. + /// The resolver used when converting a field in the database layer. + /// The resolver used to identity the type for average. + public MySqlStatementBuilder(IDbSetting dbSetting, + IResolver convertFieldResolver = null, + IResolver averageableClientTypeResolver = null) + : base(dbSetting, + convertFieldResolver, + averageableClientTypeResolver) + { } + + #region CreateBatchQuery + + /// + /// Creates a SQL Statement for batch query operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields to be queried. + /// The page of the batch. + /// The number of rows per batch. + /// The list of fields for ordering. + /// The query expression. + /// The table hints to be used. + /// A sql statement for batch query operation. + public override string CreateBatchQuery(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields, + int? page, + int? rowsPerBatch, + IEnumerable orderBy = null, + QueryGroup where = null, + string hints = null) + { + // Ensure with guards + GuardTableName(tableName); + + // Validate the hints + GuardHints(hints); + + // There should be fields + if (fields?.Any() != true) + { + throw new NullReferenceException($"The list of queryable fields must not be null for '{tableName}'."); + } + + // Validate order by + if (orderBy == null || orderBy?.Any() != true) + { + throw new EmptyException("The argument 'orderBy' is required."); + } + + // Validate the page + if (page == null || page < 0) + { + throw new ArgumentOutOfRangeException("The page must be equals or greater than 0."); + } + + // Validate the page + if (rowsPerBatch == null || rowsPerBatch < 1) + { + throw new ArgumentOutOfRangeException($"The rows per batch must be equals or greater than 1."); + } + + // Skipping variables + var skip = (page * rowsPerBatch); + + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Build the query + builder.Clear() + .Select() + .FieldsFrom(fields, DbSetting) + .From() + .TableNameFrom(tableName, DbSetting) + .WhereFrom(where, DbSetting) + .OrderByFrom(orderBy, DbSetting) + .LimitTake(rowsPerBatch, skip) + .End(); + + // Return the query + return queryBuilder.GetString(); + } + + #endregion + + #region CreateCount + + /// + /// Creates a SQL Statement for count operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The query expression. + /// The table hints to be used. + /// A sql statement for count operation. + public override string CreateCount(QueryBuilder queryBuilder, + string tableName, + QueryGroup where = null, + string hints = null) + { + var result = base.CreateCount(queryBuilder, + tableName, + where, + hints); + + // Return the query + return result.Replace("COUNT (", "COUNT("); + } + + #endregion + + #region CreateCountAll + + /// + /// Creates a SQL Statement for count-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The table hints to be used. + /// A sql statement for count-all operation. + public override string CreateCountAll(QueryBuilder queryBuilder, + string tableName, + string hints = null) + { + var result = base.CreateCountAll(queryBuilder, + tableName, + hints); + + // Return the query + return result.Replace("COUNT (", "COUNT("); + } + + #endregion + + #region CreateExists + + /// + /// Creates a SQL Statement for exists operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The query expression. + /// The table hints to be used. + /// A sql statement for exists operation. + public override string CreateExists(QueryBuilder queryBuilder, + string tableName, + QueryGroup where = null, + string hints = null) + { + // Ensure with guards + GuardTableName(tableName); + + // Validate the hints + GuardHints(hints); + + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Build the query + builder.Clear() + .Select() + .WriteText($"1 AS {("ExistsValue").AsQuoted(DbSetting)}") + .From() + .TableNameFrom(tableName, DbSetting) + .HintsFrom(hints) + .WhereFrom(where, DbSetting) + .Limit(1) + .End(); + + // Return the query + return builder.GetString(); + } + + #endregion + + #region CreateInsert + + /// + /// Creates a SQL Statement for insert operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields to be inserted. + /// The primary field from the database. + /// The identity field from the database. + /// The table hints to be used. + /// A sql statement for insert operation. + public override string CreateInsert(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields = null, + DbField primaryField = null, + DbField identityField = null, + string hints = null) + { + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Call the base + base.CreateInsert(builder, + tableName, + fields, + primaryField, + identityField, + hints); + + // Set the return value + var result = identityField != null ? + string.Concat($"LAST_INSERT_ID()") : + primaryField != null ? primaryField.Name.AsParameter(DbSetting) : "NULL"; + + builder + .Select() + .WriteText(result) + .As("Result".AsQuoted(DbSetting)) + .End(); + + // Return the query + return builder.GetString(); + } + + #endregion + + #region CreateInsertAll + + /// + /// Creates a SQL Statement for insert-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields to be inserted. + /// The batch size of the operation. + /// The primary field from the database. + /// The identity field from the database. + /// The table hints to be used. + /// A sql statement for insert operation. + public override string CreateInsertAll(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields = null, + int batchSize = 1, + DbField primaryField = null, + DbField identityField = null, + string hints = null) + { + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Call the base + var commandText = base.CreateInsertAll(builder, + tableName, + fields, + batchSize, + primaryField, + identityField, + hints); + + if (identityField != null) + { + // Variables needed + var commandTexts = new List(); + var splitted = commandText.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); + + // Iterate the indexes + for (var index = 0; index < splitted.Count(); index++) + { + var line = splitted[index].Trim(); + var returnValue = "SELECT LAST_INSERT_ID()"; + commandTexts.Add(string.Concat(line, " ; ", returnValue, " ;")); + } + + // Set the command text + commandText = commandTexts.Join(" "); + } + + // Return the query + return commandText; + } + + #endregion + + #region CreateMax + + /// + /// Creates a SQL Statement for maximum operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be maximumd. + /// The query expression. + /// The table hints to be used. + /// A sql statement for maximum operation. + public override string CreateMax(QueryBuilder queryBuilder, + string tableName, + Field field, + QueryGroup where = null, + string hints = null) + { + var result = base.CreateMax(queryBuilder, + tableName, + field, + where, + hints); + + // Return the query + return result.Replace("MAX (", "MAX("); + } + + #endregion + + #region CreateMaxAll + + /// + /// Creates a SQL Statement for maximum-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be maximumd. + /// The table hints to be used. + /// A sql statement for maximum-all operation. + public override string CreateMaxAll(QueryBuilder queryBuilder, + string tableName, + Field field, + string hints = null) + { + var result = base.CreateMaxAll(queryBuilder, + tableName, + field, + hints); + + // Return the query + return result.Replace("MAX (", "MAX("); + } + + #endregion + + #region CreateMerge + + /// + /// Creates a SQL Statement for merge operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields to be merged. + /// The list of the qualifier objects. + /// The primary field from the database. + /// The identity field from the database. + /// The table hints to be used. + /// A sql statement for merge operation. + public override string CreateMerge(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields, + IEnumerable qualifiers = null, + DbField primaryField = null, + DbField identityField = null, + string hints = null) + { + // Ensure with guards + GuardTableName(tableName); + GuardHints(hints); + GuardPrimary(primaryField); + GuardIdentity(identityField); + + // Verify the fields + if (fields?.Any() != true) + { + throw new NullReferenceException($"The list of fields cannot be null or empty."); + } + + // Check the primay field + if (primaryField == null) + { + throw new PrimaryFieldNotFoundException($"MySql is using the primary key as qualifier for merge operation."); + } + + // Check the qualifiers + if (qualifiers?.Any() == true) + { + var others = qualifiers.Where(f => !string.Equals(f.Name, primaryField?.Name, StringComparison.OrdinalIgnoreCase)); + if (others?.Any() == true) + { + throw new InvalidQualifiersException($"MySql is using the primary key as qualifier for merge operation. " + + $"Consider creating 'PrimaryKey' in the {tableName} and set the 'qualifiers' to NULL."); + } + } + + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Set the return value + var result = (string)null; + + // Check both primary and identity + if (identityField != null && !string.Equals(identityField.Name, primaryField.Name, StringComparison.OrdinalIgnoreCase)) + { + result = string.Concat($"(CASE WHEN {identityField.Name.AsParameter(DbSetting)} > 0 THEN " + + $"{identityField.Name.AsParameter(DbSetting)} ELSE " + + $"{primaryField.Name.AsParameter(DbSetting)} END)"); + } + else + { + result = string.Concat($"COALESCE({primaryField.Name.AsParameter(DbSetting)}, LAST_INSERT_ID())"); + } + + // Build the query + builder.Clear() + .Insert() + .Into() + .TableNameFrom(tableName, DbSetting) + .OpenParen() + .FieldsFrom(fields, DbSetting) + .CloseParen() + .Values() + .OpenParen() + .ParametersFrom(fields, 0, DbSetting) + .CloseParen() + .WriteText("ON DUPLICATE KEY") + .Update() + .FieldsAndParametersFrom(fields, 0, DbSetting) + .End(); + + if (!string.IsNullOrEmpty(result)) + { + // Set the result + builder + .Select() + .WriteText(result) + .As("Result".AsQuoted(DbSetting)) + .End(); + } + + // Return the query + return builder.GetString(); + } + + #endregion + + #region CreateMergeAll + + /// + /// Creates a SQL Statement for merge-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields to be merged. + /// The list of the qualifier objects. + /// The batch size of the operation. + /// The primary field from the database. + /// The identity field from the database. + /// The table hints to be used. + /// A sql statement for merge operation. + public override string CreateMergeAll(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields, + IEnumerable qualifiers, + int batchSize = 10, + DbField primaryField = null, + DbField identityField = null, + string hints = null) + { + // Ensure with guards + GuardTableName(tableName); + GuardHints(hints); + GuardPrimary(primaryField); + GuardIdentity(identityField); + + // Verify the fields + if (fields?.Any() != true) + { + throw new NullReferenceException($"The list of fields cannot be null or empty."); + } + + // Check the primay field + if (primaryField == null) + { + throw new PrimaryFieldNotFoundException($"MySql is using the primary key as qualifier for merge operation."); + } + + // Check the qualifiers + if (qualifiers?.Any() == true) + { + var others = qualifiers.Where(f => !string.Equals(f.Name, primaryField?.Name, StringComparison.OrdinalIgnoreCase)); + if (others?.Any() == true) + { + throw new InvalidQualifiersException($"MySql is using the primary key as qualifier for merge operation. " + + $"Consider creating 'PrimaryKey' in the {tableName} and set the 'qualifiers' to NULL."); + } + } + + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Set the return value + var result = (string)null; + + // Clear the builder + builder.Clear(); + + // Iterate the indexes + for (var index = 0; index < batchSize; index++) + { + // Build the query + builder + .Insert() + .Into() + .TableNameFrom(tableName, DbSetting) + .OpenParen() + .FieldsFrom(fields, DbSetting) + .CloseParen() + .Values() + .OpenParen() + .ParametersFrom(fields, index, DbSetting) + .CloseParen() + .WriteText("ON DUPLICATE KEY") + .Update() + .FieldsAndParametersFrom(fields, index, DbSetting) + .End(); + + // Check both primary and identity + if (identityField != null && !string.Equals(identityField.Name, primaryField.Name, StringComparison.OrdinalIgnoreCase)) + { + result = string.Concat($"(CASE WHEN {identityField.Name.AsParameter(index, DbSetting)} > 0 THEN " + + $"{identityField.Name.AsParameter(index, DbSetting)} ELSE " + + $"{primaryField.Name.AsParameter(index, DbSetting)} END)"); + } + else + { + result = string.Concat($"COALESCE({primaryField.Name.AsParameter(index, DbSetting)}, LAST_INSERT_ID())"); + } + + if (!string.IsNullOrEmpty(result)) + { + // Set the result + builder + .Select() + .WriteText(result) + .As("Result".AsQuoted(DbSetting)) + .End(); + } + } + + // Return the query + return builder.GetString(); + } + + #endregion + + #region CreateMin + + /// + /// Creates a SQL Statement for minimum operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be minimumd. + /// The query expression. + /// The table hints to be used. + /// A sql statement for minimum operation. + public override string CreateMin(QueryBuilder queryBuilder, + string tableName, + Field field, + QueryGroup where = null, + string hints = null) + { + var result = base.CreateMin(queryBuilder, + tableName, + field, + where, + hints); + + // Return the query + return result.Replace("MIN (", "MIN("); + } + + #endregion + + #region CreateMinAll + + /// + /// Creates a SQL Statement for minimum-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be minimumd. + /// The table hints to be used. + /// A sql statement for minimum-all operation. + public override string CreateMinAll(QueryBuilder queryBuilder, + string tableName, + Field field, + string hints = null) + { + var result = base.CreateMinAll(queryBuilder, + tableName, + field, + hints); + + // Return the query + return result.Replace("MIN (", "MIN("); + } + + #endregion + + #region CreateQuery + + /// + /// Creates a SQL Statement for query operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The list of fields. + /// The query expression. + /// The list of fields for ordering. + /// The number of rows to be returned. + /// The table hints to be used. + /// A sql statement for query operation. + public override string CreateQuery(QueryBuilder queryBuilder, + string tableName, + IEnumerable fields, + QueryGroup where = null, + IEnumerable orderBy = null, + int? top = null, + string hints = null) + { + // Ensure with guards + GuardTableName(tableName); + + // Validate the hints + GuardHints(hints); + + // There should be fields + if (fields?.Any() != true) + { + throw new NullReferenceException($"The list of queryable fields must not be null for '{tableName}'."); + } + + // Validate the ordering + if (orderBy != null) + { + // Check if the order fields are present in the given fields + var unmatchesOrderFields = orderBy?.Where(orderField => + fields?.FirstOrDefault(f => + string.Equals(orderField.Name, f.Name, StringComparison.OrdinalIgnoreCase)) == null); + + // Throw an error we found any unmatches + if (unmatchesOrderFields?.Any() == true) + { + throw new MissingFieldsException($"The order fields '{unmatchesOrderFields.Select(field => field.Name).Join(", ")}' are not " + + $"present at the given fields '{fields.Select(field => field.Name).Join(", ")}'."); + } + } + + // Initialize the builder + var builder = queryBuilder ?? new QueryBuilder(); + + // Build the query + builder.Clear() + .Select() + .FieldsFrom(fields, DbSetting) + .From() + .TableNameFrom(tableName, DbSetting) + .HintsFrom(hints) + .WhereFrom(where, DbSetting) + .OrderByFrom(orderBy, DbSetting); + if (top > 0) + { + builder.Limit(top); + } + builder.End(); + + // Return the query + return builder.GetString(); + } + + #endregion + + #region CreateSum + + /// + /// Creates a SQL Statement for sum operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be sumd. + /// The query expression. + /// The table hints to be used. + /// A sql statement for sum operation. + public override string CreateSum(QueryBuilder queryBuilder, + string tableName, + Field field, + QueryGroup where = null, + string hints = null) + { + var result = base.CreateSum(queryBuilder, + tableName, + field, + where, + hints); + + // Return the query + return result.Replace("SUM (", "SUM("); + } + + #endregion + + #region CreateSumAll + + /// + /// Creates a SQL Statement for sum-all operation. + /// + /// The query builder to be used. + /// The name of the target table. + /// The field to be sumd. + /// The table hints to be used. + /// A sql statement for sum-all operation. + public override string CreateSumAll(QueryBuilder queryBuilder, + string tableName, + Field field, + string hints = null) + { + var result = base.CreateSumAll(queryBuilder, + tableName, + field, + hints); + + // Return the query + return result.Replace("SUM (", "SUM("); + } + + #endregion + } +}