diff --git a/DynamORM.Tests/Modify/ParserTests.cs b/DynamORM.Tests/Modify/ParserTests.cs index 9cdc1c6..a5216ab 100644 --- a/DynamORM.Tests/Modify/ParserTests.cs +++ b/DynamORM.Tests/Modify/ParserTests.cs @@ -66,7 +66,7 @@ namespace DynamORM.Tests.Modify /// Tests the basic insert. /// [Test] - public void TestInsertBasic() + public void TestTypedInsertBasic() { IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users"); diff --git a/DynamORM.Tests/Modify/TypedModifyExtensionsTests.cs b/DynamORM.Tests/Modify/TypedModifyExtensionsTests.cs index ac41e42..d138246 100644 --- a/DynamORM.Tests/Modify/TypedModifyExtensionsTests.cs +++ b/DynamORM.Tests/Modify/TypedModifyExtensionsTests.cs @@ -4,8 +4,6 @@ * All rights reserved. */ -using System.Linq; -using DynamORM.Builders; using DynamORM.Tests.Helpers; using NUnit.Framework; @@ -35,7 +33,7 @@ namespace DynamORM.Tests.Modify [Test] public void TestTypedUpdateBuilderSetAndWhere() { - var cmd = Database.Update() + var cmd = Database.UpdateTyped() .Set(u => u.Code, "778") .Where(u => u.Id == 1 && u.Code == "1"); @@ -50,7 +48,7 @@ namespace DynamORM.Tests.Modify [Test] public void TestTypedDeleteBuilderWhere() { - var cmd = Database.Delete() + var cmd = Database.DeleteTyped() .Where(u => u.Id == 3); Assert.AreEqual( @@ -61,7 +59,7 @@ namespace DynamORM.Tests.Modify [Test] public void TestTypedInsertBuilderColumns() { - var cmd = Database.Insert() + var cmd = Database.InsertTyped() .Insert(u => u.Code, "901") .Insert(u => u.First, "TypedB"); diff --git a/DynamORM.Tests/Modify/TypedParserTests.cs b/DynamORM.Tests/Modify/TypedParserTests.cs new file mode 100644 index 0000000..e20ae79 --- /dev/null +++ b/DynamORM.Tests/Modify/TypedParserTests.cs @@ -0,0 +1,224 @@ +/* + * DynamORM - Dynamic Object-Relational Mapping library. + * Copyright (c) 2012-2026, Grzegorz Russek (grzegorz.russek@gmail.com) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. +*/ + +using System.Linq; +using DynamORM.Builders; +using DynamORM.Builders.Implementation; +using NUnit.Framework; +using DynamORM.Tests.Helpers; +using System.Collections.Generic; +using static System.Data.Entity.Infrastructure.Design.Executor; +using System.Runtime.InteropServices; + +namespace DynamORM.Tests.Modify +{ + /// New parser tests. + [TestFixture] + public class TypedParserTests : TestsBase + { + /// Setup test parameters. + [SetUp] + public virtual void SetUp() + { + CreateTestDatabase(); + CreateDynamicDatabase( + DynamicDatabaseOptions.SingleConnection | + DynamicDatabaseOptions.SingleTransaction | + DynamicDatabaseOptions.SupportLimitOffset); + } + + /// Tear down test objects. + [TearDown] + public virtual void TearDown() + { + DestroyDynamicDatabase(); + DestroyTestDatabase(); + } + + #region Insert + + /// + /// Tests the basic insert. + /// + [Test] + public void TestTypedInsertBasic() + { + var cmd = new DynamicTypedInsertQueryBuilder(Database); + + cmd.Values(x => x.Users.Code = "001", x => x.Users.Name = "Admin", x => x.Users.IsAdmin = 1); + + Assert.AreEqual(string.Format(@"INSERT INTO ""Users"" (""Code"", ""Name"", ""IsAdmin"") VALUES ({0})", + string.Join(", ", cmd.Parameters.Keys.Select(p => string.Format("[${0}]", p)))), cmd.CommandText()); + } + + /// + /// Tests the insert with sub query. + /// + [Test] + public void TestInsertSubQuery() + { + var cmd = new DynamicTypedInsertQueryBuilder(Database); + + cmd.Values(x => x.Code = "001", x => x.Name = "Admin", x => x.IsAdmin = x(cmd + .SubQuery(a => a.AccessRights.As(a.a)) + .Select(a => a.IsAdmin) + .Where(a => a.User_Id == "001"))); + + Assert.AreEqual(string.Format(@"INSERT INTO ""Users"" (""Code"", ""Name"", ""IsAdmin"") VALUES ({0}, (SELECT a.""IsAdmin"" FROM ""AccessRights"" AS a WHERE (a.""User_Id"" = [${1}])))", + string.Join(", ", cmd.Parameters.Keys.Take(2).Select(p => string.Format("[${0}]", p))), cmd.Parameters.Keys.Last()), cmd.CommandText()); + } + + /// + /// Tests the basic insert using object. + /// + [Test] + public void TestInsertBasicObject() + { + var cmd = new DynamicTypedInsertQueryBuilder(Database); + cmd.Values(x => new { Code = "001", Name = "Admin", IsAdmin = 1 }); + + Assert.AreEqual(string.Format(@"INSERT INTO ""Users"" (""Code"", ""Name"", ""IsAdmin"") VALUES ({0})", + string.Join(", ", cmd.Parameters.Keys.Select(p => string.Format("[${0}]", p)))), cmd.CommandText()); + } + + /// + /// Tests the insert using object with sub query. + /// + [Test] + public void TestInsertSubQueryObject() + { + var cmd = new DynamicTypedInsertQueryBuilder(Database); + + cmd.Values(x => new + { + Code = "001", + Name = "Admin", + IsAdmin = x(cmd + .SubQuery(a => a.AccessRights.As(a.a)) + .Select(a => a.IsAdmin) + .Where(a => a.User_Id == "001")) + }); + + Assert.AreEqual(string.Format(@"INSERT INTO ""Users"" (""Code"", ""Name"", ""IsAdmin"") VALUES ({0}, (SELECT a.""IsAdmin"" FROM ""AccessRights"" AS a WHERE (a.""User_Id"" = [${1}])))", + string.Join(", ", cmd.Parameters.Keys.Take(2).Select(p => string.Format("[${0}]", p))), cmd.Parameters.Keys.Last()), cmd.CommandText()); + } + + #endregion Insert + + #region Update + + /// + /// Tests the basic update. + /// + [Test] + public void TestUpdateBasicSet() + { + var cmd = new DynamicTypedUpdateQueryBuilder(Database); + + cmd.Set(x => x.Users.Code = "001", x => x.Users.Name = "Admin", x => x.Users.IsAdmin = 1) + .Where(x => x.Users.Id_User == 1); + + Assert.AreEqual(string.Format(@"UPDATE ""Users"" SET ""Code"" = [${0}], ""Name"" = [${1}], ""IsAdmin"" = [${2}] WHERE (""Users"".""Id_User"" = [${3}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], cmd.Parameters.Keys.ToArray()[3]), cmd.CommandText()); + } + + /// + /// Tests the basic update. + /// + [Test] + public void TestUpdateBasicValues() + { + var cmd = new DynamicTypedUpdateQueryBuilder(Database); + + cmd + .Values("Code", "001") + .Values("Name", "Admin") + .Values("IsAdmin", "1") + .Where(x => x.Users.Id_User == 1); + + Assert.AreEqual(string.Format(@"UPDATE ""Users"" SET ""Code"" = [${0}], ""Name"" = [${1}], ""IsAdmin"" = [${2}] WHERE (""Users"".""Id_User"" = [${3}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], cmd.Parameters.Keys.ToArray()[3]), cmd.CommandText()); + } + + /// + /// Tests the insert with sub query. + /// + [Test] + public void TestUpdateSubQuery() + { + var cmd = new DynamicTypedUpdateQueryBuilder(Database); + cmd.Set(x => x.Users.Code = "001", x => x.Users.Name = "Admin", x => x.Users.IsAdmin = x(cmd + .SubQuery(a => a.AccessRights.As(a.a)) + .Select(a => a.IsAdmin) + .Where(a => a.User_Id == a.Users.Id_User))) + .Where(x => x.Users.Id_User == 1); + + Assert.AreEqual(string.Format(@"UPDATE ""Users"" SET ""Code"" = [${0}], ""Name"" = [${1}], ""IsAdmin"" = (SELECT a.""IsAdmin"" FROM ""AccessRights"" AS a WHERE (a.""User_Id"" = ""Users"".""Id_User"")) WHERE (""Users"".""Id_User"" = [${2}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + /// + /// Tests the basic insert using object. + /// + [Test] + public void TestUpdateBasicObject() + { + var cmd = new DynamicTypedUpdateQueryBuilder(Database); + + cmd.Set(x => new { Code = "001", Name = "Admin", IsAdmin = 1 }) + .Where(x => new { Id_User = 1 }); + + Assert.AreEqual(string.Format(@"UPDATE ""Users"" SET ""Code"" = [${0}], ""Name"" = [${1}], ""IsAdmin"" = [${2}] WHERE (""Id_User"" = [${3}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], cmd.Parameters.Keys.ToArray()[3]), cmd.CommandText()); + } + + /// + /// Tests the basic insert using object. + /// + [Test] + public void TestUpdateSubQueryObject() + { + var cmd = new DynamicTypedUpdateQueryBuilder(Database); + + cmd.Set(x => new + { + Code = "001", + Name = "Admin", + IsAdmin = x(cmd + .SubQuery(a => a.AccessRights.As(a.a)) + .Select(a => a.IsAdmin) + .Where(a => a.User_Id == a.Users.Id_User)) + }).Where(x => new { Id_User = 1 }); + + Assert.AreEqual(string.Format(@"UPDATE ""Users"" SET ""Code"" = [${0}], ""Name"" = [${1}], ""IsAdmin"" = (SELECT a.""IsAdmin"" FROM ""AccessRights"" AS a WHERE (a.""User_Id"" = ""Users"".""Id_User"")) WHERE (""Id_User"" = [${2}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + #endregion Update + } +} \ No newline at end of file diff --git a/DynamORM.Tests/Select/TypedFluentBuilderTests.cs b/DynamORM.Tests/Select/TypedFluentBuilderTests.cs index c8c16b8..968e120 100644 --- a/DynamORM.Tests/Select/TypedFluentBuilderTests.cs +++ b/DynamORM.Tests/Select/TypedFluentBuilderTests.cs @@ -26,7 +26,6 @@ * THE POSSIBILITY OF SUCH DAMAGE. */ -using System.Linq; using DynamORM.Builders; using DynamORM.Tests.Helpers; using NUnit.Framework; @@ -56,7 +55,7 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedWhereAndSelectUsesPropertyMap() { - var cmd = Database.From("u") + var cmd = Database.FromTyped("u") .Where(u => u.Id == 1) .Select(u => u.Code.As("CodeAlias")) .OrderBy(u => u.Code.Desc()); @@ -71,7 +70,7 @@ namespace DynamORM.Tests.Select { var ids = new[] { 1L, 2L, 3L }.ToList(); - var cmd = Database.From("u") + var cmd = Database.FromTyped("u") .Where(u => ids.Contains(u.Id)) .Select(u => u.Id); @@ -86,7 +85,7 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedGroupByHavingOrderBy() { - var cmd = Database.From("u") + var cmd = Database.FromTyped("u") .Select(u => u.Code) .GroupBy(u => u.Code) .Having(u => u.Code != null) @@ -99,7 +98,7 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedJoin() { - var cmd = Database.From("u") + var cmd = Database.FromTyped("u") .Join(j => j.As("x").On((l, r) => l.Id == r.Id)) .Select(u => u.Id); @@ -110,7 +109,7 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedLeftJoin() { - var cmd = Database.From("u") + var cmd = Database.FromTyped("u") .Join(j => j.Left().As("x").On((l, r) => l.Id == r.Id)) .Select(u => u.Id); @@ -121,8 +120,8 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedRightJoin() { - var cmd = Database.From("u") - .RightJoin((l, r) => l.Id == r.Id, "x") + var cmd = Database.FromTyped("u") + .Join(j => j.Right().As("X").On((l, r) => l.Id == r.Id)) .Select(u => u.Id); Assert.AreEqual("SELECT u.\"id_user\" FROM \"sample_users\" AS u RIGHT JOIN \"sample_users\" AS x ON (u.\"id_user\" = x.\"id_user\")", @@ -132,8 +131,8 @@ namespace DynamORM.Tests.Select [Test] public void TestTypedFullJoin() { - var cmd = Database.From("u") - .FullJoin((l, r) => l.Id == r.Id, "x") + var cmd = Database.FromTyped("u") + .Join(j => j.Full().As("X").On((l, r) => l.Id == r.Id)) .Select(u => u.Id); Assert.AreEqual("SELECT u.\"id_user\" FROM \"sample_users\" AS u FULL JOIN \"sample_users\" AS x ON (u.\"id_user\" = x.\"id_user\")", diff --git a/DynamORM.Tests/Select/TypedParserTests.cs b/DynamORM.Tests/Select/TypedParserTests.cs new file mode 100644 index 0000000..ae50f7e --- /dev/null +++ b/DynamORM.Tests/Select/TypedParserTests.cs @@ -0,0 +1,860 @@ +/* + * DynamORM - Dynamic Object-Relational Mapping library. + * Copyright (c) 2012-2026, Grzegorz Russek (grzegorz.russek@gmail.com) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. +*/ + +using System.Linq; +using DynamORM.Builders; +using DynamORM.Builders.Implementation; +using DynamORM.Tests.Helpers; +using NUnit.Framework; + +namespace DynamORM.Tests.Select +{ + /// + /// New parser tests. + /// + [TestFixture] + public class TypedParserTests : TestsBase + { + /// Setup test parameters. + [SetUp] + public virtual void SetUp() + { + CreateTestDatabase(); + CreateDynamicDatabase( + DynamicDatabaseOptions.SingleConnection | + DynamicDatabaseOptions.SingleTransaction | + DynamicDatabaseOptions.SupportLimitOffset | + DynamicDatabaseOptions.SupportNoLock); + } + + /// Tear down test objects. + [TearDown] + public virtual void TearDown() + { + try + { + DestroyDynamicDatabase(); + DestroyTestDatabase(); + } + catch { } + } + + + /// + /// Tests from typed method. + /// + [Test] + public void TestFromGetTyped() + { + var cmd = Database.From(); + + Assert.AreEqual("SELECT * FROM \"sample_users\"", cmd.CommandText()); + } + + /// + /// Tests from typed method. + /// + [Test] + public void TestFromGetTypedAs() + { + var cmd = Database.From("u"); + + Assert.AreEqual("SELECT * FROM \"sample_users\" AS u", cmd.CommandText()); + } + + /// + /// Tests from method using invoke with sub query. + /// + [Test] + public void TestFromSubQuery4() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u(new DynamicSelectQueryBuilder(Database).From(x => x.dbo.Users.NoLock())).As("u")); + + Assert.AreEqual("SELECT * FROM (SELECT * FROM \"dbo\".\"Users\" WITH(NOLOCK)) AS u", cmd.CommandText()); + } + + /// + /// Tests where method with alias. + /// + [Test] + public void TestWhereAlias() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.UserName == "admin"); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE (c.\"UserName\" = [${0}])", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests where method with alias. + /// + [Test] + public void TestHavingAlias() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Having(u => u.Sum(u.c.ClientsCount) > 10); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c HAVING (Sum(c.\"ClientsCount\") > [${0}])", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests complex where method with alias. + /// + [Test] + public void TestWhereAliasComplex() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.UserName == "admin" || u.c.UserName == "root") + .Where(u => u.c.IsActive = true); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE ((c.\"UserName\" = [${0}]) OR (c.\"UserName\" = [${1}])) AND c.\"IsActive\" = ([${2}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + /// + /// Tests where method with alias using in. + /// + [Test] + public void TestWhereAliasIn() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + int[] ids = new int[] { 0, 1, 2, 3, 4, 5 }; + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.UserName == "admin" || u.c.UserName == "root") + .Where(u => u.c.IsActive == true) + .Where(u => u.c.Id_User.In(ids)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE ((c.\"UserName\" = [${0}]) OR (c.\"UserName\" = [${1}])) AND (c.\"IsActive\" = [${2}]) AND c.\"Id_User\" IN({3})", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], + string.Join(", ", cmd.Parameters.Keys.Skip(3).Select(p => string.Format("[${0}]", p)))), cmd.CommandText()); + } + + /// + /// Tests where method with alias using between. + /// + [Test] + public void TestWhereAliasBetween1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + int[] ids = new int[] { 0, 5 }; + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.UserName == "admin" || u.c.UserName == "root") + .Where(u => u.c.IsActive == true) + .Where(u => u.c.Id_User.Between(ids)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE ((c.\"UserName\" = [${0}]) OR (c.\"UserName\" = [${1}])) AND (c.\"IsActive\" = [${2}]) AND c.\"Id_User\" BETWEEN [${3}] AND [${4}]", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], + cmd.Parameters.Keys.ToArray()[3], cmd.Parameters.Keys.ToArray()[4]), cmd.CommandText()); + } + + /// + /// Tests where method with alias using between. + /// + [Test] + public void TestWhereAliasBetween2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + int[] ids = new int[] { 0, 5 }; + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.UserName == "admin" || u.c.UserName == "root") + .Where(u => u.c.IsActive == true) + .Where(u => u.c.Id_User.Between(ids[0], ids[1])); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE ((c.\"UserName\" = [${0}]) OR (c.\"UserName\" = [${1}])) AND (c.\"IsActive\" = [${2}]) AND c.\"Id_User\" BETWEEN [${3}] AND [${4}]", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2], + cmd.Parameters.Keys.ToArray()[3], cmd.Parameters.Keys.ToArray()[4]), cmd.CommandText()); + } + + /// + /// Tests where method without alias. + /// + [Test] + public void TestWhereNoAlias() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Where(u => u.UserName == "admin"); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" WHERE (\"UserName\" = [${0}])", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests where method with full column name. + /// + [Test] + public void TestWhereNoAliasTableName() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Where(u => u.dbo.Users.UserName == "admin"); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" WHERE (\"dbo\".\"Users\".\"UserName\" = [${0}])", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests simple join method. + /// + [Test] + public void TestJoinClassic() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests inner join method. + /// + [Test] + public void TestInnerJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.Inner().dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr INNER JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests inner join method with aliases mix. + /// + [Test] + public void TestInnerJoin2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(usr => usr.Inner().dbo.UserClients.AS(usr.uc).On(usr.Id_User == usr.uc.User_Id && usr.uc.Users != null)) + .Select(usr => usr.All(), uc => uc.Users); + + Assert.AreEqual(string.Format("SELECT usr.*, uc.\"Users\" FROM \"dbo\".\"Users\" AS usr INNER JOIN \"dbo\".\"UserClients\" AS uc ON ((usr.\"Id_User\" = uc.\"User_Id\") AND (uc.\"Users\" IS NOT NULL))"), cmd.CommandText()); + } + + /// + /// Tests from method using invoke with sub query. + /// + [Test] + public void TestInnerJoin3() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .SubQuery((b, s) => b.Join(usr => usr(s.From(x => x.dbo.UserClients)).Inner().As(usr.uc).On(usr.Id_User == usr.uc.User_Id && usr.uc.Users != null))) + .Select(usr => usr.All(), uc => uc.Users); + + Assert.AreEqual(string.Format("SELECT usr.*, uc.\"Users\" FROM \"dbo\".\"Users\" AS usr INNER JOIN (SELECT * FROM \"dbo\".\"UserClients\") AS uc ON ((usr.\"Id_User\" = uc.\"User_Id\") AND (uc.\"Users\" IS NOT NULL))"), cmd.CommandText()); + } + + /// + /// Tests from method using invoke with sub query. + /// + [Test] + public void TestInnerJoin4() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .SubQuery((b, s) => b.Join(usr => usr(s.From(x => x.dbo.UserClients).Where(x => x.Deleted == 0)).Inner().As(usr.uc).On(usr.Id_User == usr.uc.User_Id && usr.uc.Users != null))) + .Select(usr => usr.All(), uc => uc.Users); + + Assert.AreEqual(string.Format("SELECT usr.*, uc.\"Users\" FROM \"dbo\".\"Users\" AS usr INNER JOIN (SELECT * FROM \"dbo\".\"UserClients\" WHERE (\"Deleted\" = [${0}])) AS uc ON ((usr.\"Id_User\" = uc.\"User_Id\") AND (uc.\"Users\" IS NOT NULL))", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests from method using invoke with sub query an no lock. + /// + [Test] + public void TestInnerJoin5() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr).NoLock()) + .SubQuery((b, s) => b.Join(usr => usr(s.From(x => x.dbo.UserClients.NoLock()).Where(x => x.Deleted == 0)).Inner().As(usr.uc).On(usr.Id_User == usr.uc.User_Id && usr.uc.Users != null))) + .Select(usr => usr.All(), uc => uc.Users); + + Assert.AreEqual(string.Format("SELECT usr.*, uc.\"Users\" FROM \"dbo\".\"Users\" AS usr WITH(NOLOCK) INNER JOIN (SELECT * FROM \"dbo\".\"UserClients\" WITH(NOLOCK) WHERE (\"Deleted\" = [${0}])) AS uc ON ((usr.\"Id_User\" = uc.\"User_Id\") AND (uc.\"Users\" IS NOT NULL))", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests inner join method with no lock. + /// + [Test] + public void TestInnerJoin6() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr).NoLock()) + .Join(u => u.Inner().dbo.UserClients.AS(u.uc).NoLock().On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr WITH(NOLOCK) INNER JOIN \"dbo\".\"UserClients\" AS uc WITH(NOLOCK) ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests left outer join method. + /// + [Test] + public void TestLeftOuterJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.LeftOuter().dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr LEFT OUTER JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests left join method. + /// + [Test] + public void TestLeftJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.Left().dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr LEFT JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests right outer join method. + /// + [Test] + public void TestRightOuterJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.RightOuter().dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr RIGHT OUTER JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests right join method. + /// + [Test] + public void TestRightJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.Right().dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id)); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr RIGHT JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")"), cmd.CommandText()); + } + + /// + /// Tests complex join with parameters. + /// + [Test] + public void TestJoinClassicWithParamAndWhere() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.usr)) + .Join(u => u.dbo.UserClients.AS(u.uc).On(u.usr.Id_User == u.uc.User_Id && u.uc.Deleted == 0)) + .Where(u => u.usr.Active == true); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS usr JOIN \"dbo\".\"UserClients\" AS uc ON ((usr.\"Id_User\" = uc.\"User_Id\") AND (uc.\"Deleted\" = [${0}])) WHERE (usr.\"Active\" = [${1}])", + cmd.Parameters.Keys.First(), cmd.Parameters.Keys.Last()), cmd.CommandText()); + } + + /// + /// Tests select all. + /// + [Test] + public void TestSelectAll1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.c.All()); + + Assert.AreEqual("SELECT c.* FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select all. + /// + [Test] + public void TestSelectAll2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Select(u => u.dbo.Users.All()); + + Assert.AreEqual("SELECT \"dbo\".\"Users\".* FROM \"dbo\".\"Users\"", cmd.CommandText()); + } + + /// + /// Tests select field. + /// + [Test] + public void TestSelectField1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.c.UserName); + + Assert.AreEqual("SELECT c.\"UserName\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select field. + /// + [Test] + public void TestSelectField2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Select(u => u.dbo.Users.UserName); + + Assert.AreEqual("SELECT \"dbo\".\"Users\".\"UserName\" FROM \"dbo\".\"Users\"", cmd.CommandText()); + } + + /// + /// Tests select field with alias. + /// + [Test] + public void TestSelectFieldAlias1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.c.UserName.As(u.Name)); + + Assert.AreEqual("SELECT c.\"UserName\" AS \"Name\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select field with alias. + /// + [Test] + public void TestSelectFieldAlias2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Select(u => u.dbo.Users.UserName.As(u.Name)); + + Assert.AreEqual("SELECT \"dbo\".\"Users\".\"UserName\" AS \"Name\" FROM \"dbo\".\"Users\"", cmd.CommandText()); + } + + /// + /// Tests select field with alias. + /// + [Test] + public void TestSelectFieldAlias3() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.u)) + .Select(u => u.UserName.As(u.Name)); + + Assert.AreEqual("SELECT u.\"UserName\" AS \"Name\" FROM \"dbo\".\"Users\" AS u", cmd.CommandText()); + } + + /// + /// Tests select field with alias. + /// + [Test] + public void TestSelectFieldAlias4() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.u)) + .Select(u => u.UserName.As(u.u.Name)); + + Assert.AreEqual("SELECT u.\"UserName\" AS \"Name\" FROM \"dbo\".\"Users\" AS u", cmd.CommandText()); + } + + /// + /// Tests select aggregate field with alias (Sum). + /// + [Test] + public void TestSelectAggregateField1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.Sum(u.c.UserName).As(u.Name)); + + Assert.AreEqual("SELECT Sum(c.\"UserName\") AS \"Name\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select aggregate field with alias (Coalesce). + /// + [Test] + public void TestSelectAggregateField2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.Coalesce(u.c.UserName, u.c.FirstName + " " + u.c.LastName).As(u.Name)); + + Assert.AreEqual(string.Format("SELECT Coalesce(c.\"UserName\", ((c.\"FirstName\" + [${0}]) + c.\"LastName\")) AS \"Name\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests select aggregate field with alias (Sum). + /// + [Test] + public void TestSelectAggregateField3() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users) + .Select(u => u.Sum(u.dbo.Users.UserName)); + + Assert.AreEqual("SELECT Sum(\"dbo\".\"Users\".\"UserName\") FROM \"dbo\".\"Users\"", cmd.CommandText()); + } + + /// + /// Tests select aggregate field with alias (Sum). + /// + [Test] + public void TestSelectAggregateField4() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.Sum(u("\"UserName\"")).As(u.Name)); + + Assert.AreEqual("SELECT Sum(\"UserName\") AS \"Name\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select aggregate field with alias (Sum). + /// + [Test] + public void TestSelectAggregateField5() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u(u.Sum(u("\"UserName\"")), " + 1").As(u.Name)); + + Assert.AreEqual("SELECT Sum(\"UserName\") + 1 AS \"Name\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select from anonymous type. + /// + [Test] + public void TestSelectAnon() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => new + { + Id_User = u.c.Id_User, + Name = u.c.UserName, + }); + + Assert.AreEqual("SELECT c.\"Id_User\" AS \"Id_User\", c.\"UserName\" AS \"Name\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestSelectCaseEscaped1() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u("CASE ", u.c.IsActive, " WHEN ", 1, " THEN ", 0, " ELSE ", 1, " END").As(u.Deleted)); + + Assert.AreEqual(string.Format("SELECT CASE c.\"IsActive\" WHEN [${0}] THEN [${1}] ELSE [${2}] END AS \"Deleted\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestSelectCaseEscaped2() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u("CASE WHEN ", u.c.IsActive == 1, " THEN ", 0, " ELSE ", 1, " END").As(u.Deleted)); + + Assert.AreEqual(string.Format("SELECT CASE WHEN (c.\"IsActive\" = [${0}]) THEN [${1}] ELSE [${2}] END AS \"Deleted\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestCoalesceEscaped() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u("COALESCE(", Database.DecorateName("ServerHash"), ", ", new byte[16] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, ")").As(u.Hash)); + + Assert.AreEqual(string.Format("SELECT COALESCE(\"ServerHash\", [${0}]) AS \"Hash\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0]), cmd.CommandText()); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestCoalesce() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.Coalesce(u.c.ServerHash, new byte[16] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }).As(u.Hash)); + + Assert.AreEqual(string.Format("SELECT Coalesce(c.\"ServerHash\", [${0}]) AS \"Hash\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0]), cmd.CommandText()); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestCoalesceCalculatedArgs() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.Coalesce(u.c.Test1 + "_", u.c.Test2 + "_", u.c.Test3 + "_").As(u.Hash)); + + Assert.AreEqual(string.Format("SELECT Coalesce((c.\"Test1\" + [${0}]), (c.\"Test2\" + [${1}]), (c.\"Test3\" + [${2}])) AS \"Hash\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + + //var c = Database.Open().CreateCommand(); + //cmd.FillCommand(c); + //c.Dispose(); + } + + /// + /// Tests select escaped case. + /// + [Test] + public void TestCoalesceInWhere() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u.ServerHash.As(u.Hash)) + .Where(u => u.Coalesce(u.c.ServerHash, new byte[16] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }) == new byte[16] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); + + Assert.AreEqual(string.Format("SELECT \"ServerHash\" AS \"Hash\" FROM \"dbo\".\"Users\" AS c WHERE (Coalesce(c.\"ServerHash\", [${0}]) = [${1}])", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1]), cmd.CommandText()); + } + + /// + /// Tests select escaped case with sub query. + /// + [Test] + public void TestSelectCaseEscapedAndSub() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u("CASE WHEN ", u.c.IsActive == 1, " AND ", u.c.IsAdmin == u(cmd.SubQuery() + .From(x => x.dbo.AccessRights.As(x.a)) + .Where(x => x.a.User_Id == x.c.Id_User) + .Select(x => x.a.IsAdmin)), " THEN ", 0, " ELSE ", 1, " END").As(u.Deleted)); + + Assert.AreEqual(string.Format("SELECT CASE WHEN (c.\"IsActive\" = [${0}]) AND (c.\"IsAdmin\" = (SELECT a.\"IsAdmin\" FROM \"dbo\".\"AccessRights\" AS a WHERE (a.\"User_Id\" = c.\"Id_User\"))) THEN [${1}] ELSE [${2}] END AS \"Deleted\" FROM \"dbo\".\"Users\" AS c", + cmd.Parameters.Keys.ToArray()[0], cmd.Parameters.Keys.ToArray()[1], cmd.Parameters.Keys.ToArray()[2]), cmd.CommandText()); + } + + /// + /// Tests group by. + /// + [Test] + public void TestGroupBy() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .GroupBy(u => u.c.UserName); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c GROUP BY c.\"UserName\"", cmd.CommandText()); + } + + /// + /// Tests order by. + /// + [Test] + public void TestOrderBy() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .OrderBy(u => u.c.UserName); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c ORDER BY c.\"UserName\" ASC", cmd.CommandText()); + } + + /// + /// Tests order by using string with number. + /// + [Test] + public void TestOrderByNumberedColumnStr() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .OrderBy(u => "1 DESC"); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c ORDER BY 1 DESC", cmd.CommandText()); + } + + /// + /// Tests order by using member with number. + /// + [Test] + public void TestOrderByNumberedColFn() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .OrderBy(u => u.Desc(1)); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c ORDER BY 1 DESC", cmd.CommandText()); + } + + /// + /// Tests order by using member with field. + /// + [Test] + public void TestOrderByAlt() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .OrderBy(u => u.Desc(u.c.UserName)); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c ORDER BY c.\"UserName\" DESC", cmd.CommandText()); + } + + /// + /// Tests sub query select. + /// + [Test] + public void TestSubQuerySelect() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Select(u => u(cmd.SubQuery() + .From(x => x.dbo.AccessRights.As(x.a)) + .Where(x => x.a.User_Id == x.c.Id_User) + .Select(x => x.a.IsAdmin)).As(u.IsAdmin)); + + Assert.AreEqual("SELECT (SELECT a.\"IsAdmin\" FROM \"dbo\".\"AccessRights\" AS a WHERE (a.\"User_Id\" = c.\"Id_User\")) AS \"IsAdmin\" FROM \"dbo\".\"Users\" AS c", cmd.CommandText()); + } + + /// + /// Tests sub query where. + /// + [Test] + public void TestSubQueryWhere() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.IsAdmin == u(cmd.SubQuery() + .From(x => x.dbo.AccessRights.As(x.a)) + .Where(x => x.a.User_Id == x.c.Id_User) + .Select(x => x.a.IsAdmin))); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c WHERE (c.\"IsAdmin\" = (SELECT a.\"IsAdmin\" FROM \"dbo\".\"AccessRights\" AS a WHERE (a.\"User_Id\" = c.\"Id_User\")))", cmd.CommandText()); + } + + /// + /// Tests sub query in. + /// + [Test] + public void TestSubQueryWhereIn() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Where(u => u.c.Id_User.In(u(cmd.SubQuery() + .From(x => x.dbo.AccessRights.As(x.a)) + .Where(x => x.a.IsAdmin == 1) + .Select(x => x.a.User_Id)))); + + Assert.AreEqual(string.Format("SELECT * FROM \"dbo\".\"Users\" AS c WHERE c.\"Id_User\" IN((SELECT a.\"User_Id\" FROM \"dbo\".\"AccessRights\" AS a WHERE (a.\"IsAdmin\" = [${0}])))", cmd.Parameters.Keys.First()), cmd.CommandText()); + } + + /// + /// Tests sub query join. + /// + [Test] + public void TestSubQueryJoin() + { + IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database); + + cmd.From(u => u.dbo.Users.As(u.c)) + .Join(u => u.Inner()(cmd.SubQuery() + .From(x => x.dbo.AccessRights.As(x.a)) + .Select(x => x.a.IsAdmin, x => x.a.User_Id)).As(u.ar).On(u.ar.User_Id == u.c.Id_User)); + + Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS c INNER JOIN (SELECT a.\"IsAdmin\", a.\"User_Id\" FROM \"dbo\".\"AccessRights\" AS a) AS ar ON (ar.\"User_Id\" = c.\"Id_User\")", cmd.CommandText()); + } + } +} \ No newline at end of file diff --git a/DynamORM/Builders/IDynamicTypedSelectQueryBuilder.cs b/DynamORM/Builders/IDynamicTypedSelectQueryBuilder.cs index bf4f420..237f30f 100644 --- a/DynamORM/Builders/IDynamicTypedSelectQueryBuilder.cs +++ b/DynamORM/Builders/IDynamicTypedSelectQueryBuilder.cs @@ -49,18 +49,6 @@ namespace DynamORM.Builders /// Builder instance. IDynamicTypedSelectQueryBuilder Join(Func, TypedJoinBuilder> specification); - /// Add INNER JOIN using typed ON predicate. - IDynamicTypedSelectQueryBuilder InnerJoin(Expression> on, string alias = null); - - /// Add LEFT JOIN using typed ON predicate. - IDynamicTypedSelectQueryBuilder LeftJoin(Expression> on, string alias = null); - - /// Add RIGHT JOIN using typed ON predicate. - IDynamicTypedSelectQueryBuilder RightJoin(Expression> on, string alias = null); - - /// Add FULL JOIN using typed ON predicate. - IDynamicTypedSelectQueryBuilder FullJoin(Expression> on, string alias = null); - /// Add typed where predicate using mapped properties. /// Predicate to parse. /// Builder instance. diff --git a/DynamORM/Builders/Implementation/DynamicTypedSelectQueryBuilder.cs b/DynamORM/Builders/Implementation/DynamicTypedSelectQueryBuilder.cs index 1e8053a..085b344 100644 --- a/DynamORM/Builders/Implementation/DynamicTypedSelectQueryBuilder.cs +++ b/DynamORM/Builders/Implementation/DynamicTypedSelectQueryBuilder.cs @@ -118,26 +118,6 @@ namespace DynamORM.Builders.Implementation return Join(spec.OnPredicate, spec.Alias, spec.JoinType); } - public IDynamicTypedSelectQueryBuilder InnerJoin(Expression> on, string alias = null) - { - return Join(on, alias, DynamicJoinType.Inner); - } - - public IDynamicTypedSelectQueryBuilder LeftJoin(Expression> on, string alias = null) - { - return Join(on, alias, DynamicJoinType.Left); - } - - public IDynamicTypedSelectQueryBuilder RightJoin(Expression> on, string alias = null) - { - return Join(on, alias, DynamicJoinType.Right); - } - - public IDynamicTypedSelectQueryBuilder FullJoin(Expression> on, string alias = null) - { - return Join(on, alias, DynamicJoinType.Full); - } - public new IDynamicTypedSelectQueryBuilder Join(params Func[] func) { base.Join(func); diff --git a/DynamORM/DynamicDatabase.cs b/DynamORM/DynamicDatabase.cs index a329123..a6e1250 100644 --- a/DynamORM/DynamicDatabase.cs +++ b/DynamORM/DynamicDatabase.cs @@ -453,28 +453,52 @@ namespace DynamORM /// Table alias. /// use no lock. /// This instance to permit chaining. - public virtual IDynamicTypedSelectQueryBuilder From(string alias = null, bool noLock = false) - { - // TODO: Make it more readable and maitainable - DynamicTypedSelectQueryBuilder builder = new DynamicTypedSelectQueryBuilder(this); - - if (noLock) - { - if (string.IsNullOrEmpty(alias)) - builder.From(x => x(typeof(T)).NoLock()); - else - builder.From(x => x(typeof(T)).As(alias).NoLock()); - } - else - { - if (string.IsNullOrEmpty(alias)) - builder.From(x => x(typeof(T))); - else - builder.From(x => x(typeof(T)).As(alias)); - } - - return builder; - } + public virtual IDynamicSelectQueryBuilder From(string alias = null, bool noLock = false) + { + // TODO: Make it more readable and maitainable + if (noLock) + { + if (string.IsNullOrEmpty(alias)) + return new DynamicSelectQueryBuilder(this).From(x => x(typeof(T)).NoLock()); + else + return new DynamicSelectQueryBuilder(this).From(x => x(typeof(T)).As(alias).NoLock()); + } + else + { + if (string.IsNullOrEmpty(alias)) + return new DynamicSelectQueryBuilder(this).From(x => x(typeof(T))); + else + return new DynamicSelectQueryBuilder(this).From(x => x(typeof(T)).As(alias)); + } + } + + /// Adds to the FROM clause using . + /// Type which can be represented in database. + /// Table alias. + /// use no lock. + /// This instance to permit chaining. + public virtual IDynamicTypedSelectQueryBuilder FromTyped(string alias = null, bool noLock = false) + { + // TODO: Make it more readable and maitainable + DynamicTypedSelectQueryBuilder builder = new DynamicTypedSelectQueryBuilder(this); + + if (noLock) + { + if (string.IsNullOrEmpty(alias)) + builder.From(x => x(typeof(T)).NoLock()); + else + builder.From(x => x(typeof(T)).As(alias).NoLock()); + } + else + { + if (string.IsNullOrEmpty(alias)) + builder.From(x => x(typeof(T))); + else + builder.From(x => x(typeof(T)).As(alias)); + } + + return builder; + } /// Adds to the FROM clause using . /// Type which can be represented in database. @@ -503,12 +527,20 @@ namespace DynamORM /// Adds to the INSERT INTO clause using . /// Type which can be represented in database. /// This instance to permit chaining. - public virtual IDynamicTypedInsertQueryBuilder Insert() - { - DynamicTypedInsertQueryBuilder builder = new DynamicTypedInsertQueryBuilder(this); - builder.Table(typeof(T)); - return builder; - } + public virtual IDynamicInsertQueryBuilder Insert() + { + return new DynamicInsertQueryBuilder(this).Table(typeof(T)); + } + + /// Adds to the INSERT INTO clause using . + /// Type which can be represented in database. + /// This instance to permit chaining. + public virtual IDynamicTypedInsertQueryBuilder InsertTyped() + { + DynamicTypedInsertQueryBuilder builder = new DynamicTypedInsertQueryBuilder(this); + builder.Table(typeof(T)); + return builder; + } /// Adds to the INSERT INTO clause using . /// Type which can be represented in database. @@ -612,12 +644,20 @@ namespace DynamORM /// Adds to the UPDATE clause using . /// Type which can be represented in database. /// This instance to permit chaining. - public virtual IDynamicTypedUpdateQueryBuilder Update() - { - DynamicTypedUpdateQueryBuilder builder = new DynamicTypedUpdateQueryBuilder(this); - builder.Table(typeof(T)); - return builder; - } + public virtual IDynamicUpdateQueryBuilder Update() + { + return new DynamicUpdateQueryBuilder(this).Table(typeof(T)); + } + + /// Adds to the UPDATE clause using . + /// Type which can be represented in database. + /// This instance to permit chaining. + public virtual IDynamicTypedUpdateQueryBuilder UpdateTyped() + { + DynamicTypedUpdateQueryBuilder builder = new DynamicTypedUpdateQueryBuilder(this); + builder.Table(typeof(T)); + return builder; + } /// Adds to the UPDATE clause using . /// Type which can be represented in database. @@ -835,12 +875,20 @@ namespace DynamORM /// Adds to the DELETE FROM clause using . /// Type which can be represented in database. /// This instance to permit chaining. - public virtual IDynamicTypedDeleteQueryBuilder Delete() - { - DynamicTypedDeleteQueryBuilder builder = new DynamicTypedDeleteQueryBuilder(this); - builder.Table(typeof(T)); - return builder; - } + public virtual IDynamicDeleteQueryBuilder Delete() + { + return new DynamicDeleteQueryBuilder(this).Table(typeof(T)); + } + + /// Adds to the DELETE FROM clause using . + /// Type which can be represented in database. + /// This instance to permit chaining. + public virtual IDynamicTypedDeleteQueryBuilder DeleteTyped() + { + DynamicTypedDeleteQueryBuilder builder = new DynamicTypedDeleteQueryBuilder(this); + builder.Table(typeof(T)); + return builder; + } /// Adds to the DELETE FROM clause using . /// Type which can be represented in database. @@ -2016,16 +2064,16 @@ namespace DynamORM #region IExtendedDisposable Members - /// Performs application-defined tasks associated with freeing, - /// releasing, or resetting unmanaged resources. - public void Dispose() - { - if (IsDisposed) - return; - -#if !DYNAMORM_OMMIT_OLDSYNTAX - List tables = TablesCache.Values.ToList(); - TablesCache.Clear(); + /// Performs application-defined tasks associated with freeing, + /// releasing, or resetting unmanaged resources. + public void Dispose() + { + if (IsDisposed) + return; + +#if !DYNAMORM_OMMIT_OLDSYNTAX + List tables = TablesCache.Values.ToList(); + TablesCache.Clear(); tables.ForEach(t => t.Dispose()); tables.Clear(); @@ -2076,18 +2124,18 @@ namespace DynamORM RemainingBuilders = null; } - ClearSchema(); - if (_proc != null) - _proc.Dispose(); - - _proc = null; - _tempConn = null; - IsDisposed = true; - } + ClearSchema(); + if (_proc != null) + _proc.Dispose(); + + _proc = null; + _tempConn = null; + IsDisposed = true; + } /// Gets a value indicating whether this instance is disposed. public bool IsDisposed { get; private set; } #endregion IExtendedDisposable Members } -} +}