Manual fix for more backward compatibility

DynamORM.Tests/Modify/ParserTests.cs

@@ -66,7 +66,7 @@ namespace DynamORM.Tests.Modify
         /// Tests the basic insert.
         /// </summary>
         [Test]
-        public void TestInsertBasic()
+        public void TestTypedInsertBasic()
         {
             IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
 

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<Users>()
+            var cmd = Database.UpdateTyped<Users>()
                 .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<Users>()
+            var cmd = Database.DeleteTyped<Users>()
                 .Where(u => u.Id == 3);
 
             Assert.AreEqual(
@@ -61,7 +59,7 @@ namespace DynamORM.Tests.Modify
         [Test]
         public void TestTypedInsertBuilderColumns()
         {
-            var cmd = Database.Insert<Users>()
+            var cmd = Database.InsertTyped<Users>()
                 .Insert(u => u.Code, "901")
                 .Insert(u => u.First, "TypedB");
 

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
+{
+    /// <summary>New parser tests.</summary>
+    [TestFixture]
+    public class TypedParserTests : TestsBase
+    {
+        /// <summary>Setup test parameters.</summary>
+        [SetUp]
+        public virtual void SetUp()
+        {
+            CreateTestDatabase();
+            CreateDynamicDatabase(
+                DynamicDatabaseOptions.SingleConnection |
+                DynamicDatabaseOptions.SingleTransaction |
+                DynamicDatabaseOptions.SupportLimitOffset);
+        }
+
+        /// <summary>Tear down test objects.</summary>
+        [TearDown]
+        public virtual void TearDown()
+        {
+            DestroyDynamicDatabase();
+            DestroyTestDatabase();
+        }
+
+        #region Insert
+
+        /// <summary>
+        /// Tests the basic insert.
+        /// </summary>
+        [Test]
+        public void TestTypedInsertBasic()
+        {
+            var cmd = new DynamicTypedInsertQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the insert with sub query.
+        /// </summary>
+        [Test]
+        public void TestInsertSubQuery()
+        {
+            var cmd = new DynamicTypedInsertQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the basic insert using object.
+        /// </summary>
+        [Test]
+        public void TestInsertBasicObject()
+        {
+            var cmd = new DynamicTypedInsertQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the insert using object with sub query.
+        /// </summary>
+        [Test]
+        public void TestInsertSubQueryObject()
+        {
+            var cmd = new DynamicTypedInsertQueryBuilder<Users>(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
+
+        /// <summary>
+        /// Tests the basic update.
+        /// </summary>
+        [Test]
+        public void TestUpdateBasicSet()
+        {
+            var cmd = new DynamicTypedUpdateQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the basic update.
+        /// </summary>
+        [Test]
+        public void TestUpdateBasicValues()
+        {
+            var cmd = new DynamicTypedUpdateQueryBuilder<Users>(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());
+        }
+        
+        /// <summary>
+        /// Tests the insert with sub query.
+        /// </summary>
+        [Test]
+        public void TestUpdateSubQuery()
+        {
+            var cmd = new DynamicTypedUpdateQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the basic insert using object.
+        /// </summary>
+        [Test]
+        public void TestUpdateBasicObject()
+        {
+            var cmd = new DynamicTypedUpdateQueryBuilder<Users>(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());
+        }
+
+        /// <summary>
+        /// Tests the basic insert using object.
+        /// </summary>
+        [Test]
+        public void TestUpdateSubQueryObject()
+        {
+            var cmd = new DynamicTypedUpdateQueryBuilder<Users>(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
+    }
+}

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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
                 .Join<TypedFluentUser>(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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
                 .Join<TypedFluentUser>(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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
-                .RightJoin<TypedFluentUser>((l, r) => l.Id == r.Id, "x")
+                .Join<TypedFluentUser>(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<TypedFluentUser>("u")
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
-                .FullJoin<TypedFluentUser>((l, r) => l.Id == r.Id, "x")
+                .Join<TypedFluentUser>(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\")",

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
+{
+    /// <summary>
+    /// New parser tests.
+    /// </summary>
+    [TestFixture]
+    public class TypedParserTests : TestsBase
+    {
+        /// <summary>Setup test parameters.</summary>
+        [SetUp]
+        public virtual void SetUp()
+        {
+            CreateTestDatabase();
+            CreateDynamicDatabase(
+                DynamicDatabaseOptions.SingleConnection |
+                DynamicDatabaseOptions.SingleTransaction |
+                DynamicDatabaseOptions.SupportLimitOffset |
+                DynamicDatabaseOptions.SupportNoLock);
+        }
+
+        /// <summary>Tear down test objects.</summary>
+        [TearDown]
+        public virtual void TearDown()
+        {
+            try
+            {
+                DestroyDynamicDatabase();
+                DestroyTestDatabase();
+            }
+            catch { }
+        }
+
+
+        /// <summary>
+        /// Tests from typed method.
+        /// </summary>
+        [Test]
+        public void TestFromGetTyped()
+        {
+            var cmd = Database.From<Users>();
+
+            Assert.AreEqual("SELECT * FROM \"sample_users\"", cmd.CommandText());
+        }
+
+        /// <summary>
+        /// Tests from typed method.
+        /// </summary>
+        [Test]
+        public void TestFromGetTypedAs()
+        {
+            var cmd = Database.From<Users>("u");
+
+            Assert.AreEqual("SELECT * FROM \"sample_users\" AS u", cmd.CommandText());
+        }
+
+        /// <summary>
+        /// Tests from method using invoke with sub query.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests complex where method with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with alias using in.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with alias using between.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with alias using between.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method without alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests where method with full column name.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests simple join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests inner join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests inner join method with aliases mix.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests from method using invoke with sub query.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests from method using invoke with sub query.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests from method using invoke with sub query an no lock.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests inner join method with no lock.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests left outer join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests left join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests right outer join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests right join method.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests complex join with parameters.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select all.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select all.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select field with alias.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select aggregate field with alias (Sum).
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select aggregate field with alias (Coalesce).
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select aggregate field with alias (Sum).
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select aggregate field with alias (Sum).
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select aggregate field with alias (Sum).
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select from anonymous type.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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();
+        }
+
+        /// <summary>
+        /// Tests select escaped case.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests select escaped case with sub query.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests group by.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests order by.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests order by using string with number.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests order by using member with number.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests order by using member with field.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests sub query select.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests sub query where.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests sub query in.
+        /// </summary>
+        [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());
+        }
+
+        /// <summary>
+        /// Tests sub query join.
+        /// </summary>
+        [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());
+        }
+    }
+}

DynamORM/Builders/IDynamicTypedSelectQueryBuilder.cs

@@ -49,18 +49,6 @@ namespace DynamORM.Builders
         /// <returns>Builder instance.</returns>
         IDynamicTypedSelectQueryBuilder<T> Join<TRight>(Func<TypedJoinBuilder<T, TRight>, TypedJoinBuilder<T, TRight>> specification);
 
-        /// <summary>Add INNER JOIN using typed ON predicate.</summary>
-        IDynamicTypedSelectQueryBuilder<T> InnerJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null);
-
-        /// <summary>Add LEFT JOIN using typed ON predicate.</summary>
-        IDynamicTypedSelectQueryBuilder<T> LeftJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null);
-
-        /// <summary>Add RIGHT JOIN using typed ON predicate.</summary>
-        IDynamicTypedSelectQueryBuilder<T> RightJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null);
-
-        /// <summary>Add FULL JOIN using typed ON predicate.</summary>
-        IDynamicTypedSelectQueryBuilder<T> FullJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null);
-
         /// <summary>Add typed where predicate using mapped properties.</summary>
         /// <param name="predicate">Predicate to parse.</param>
         /// <returns>Builder instance.</returns>

DynamORM/Builders/Implementation/DynamicTypedSelectQueryBuilder.cs

@@ -118,26 +118,6 @@ namespace DynamORM.Builders.Implementation
             return Join(spec.OnPredicate, spec.Alias, spec.JoinType);
         }
 
-        public IDynamicTypedSelectQueryBuilder<T> InnerJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null)
-        {
-            return Join(on, alias, DynamicJoinType.Inner);
-        }
-
-        public IDynamicTypedSelectQueryBuilder<T> LeftJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null)
-        {
-            return Join(on, alias, DynamicJoinType.Left);
-        }
-
-        public IDynamicTypedSelectQueryBuilder<T> RightJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null)
-        {
-            return Join(on, alias, DynamicJoinType.Right);
-        }
-
-        public IDynamicTypedSelectQueryBuilder<T> FullJoin<TRight>(Expression<Func<T, TRight, bool>> on, string alias = null)
-        {
-            return Join(on, alias, DynamicJoinType.Full);
-        }
-
         public new IDynamicTypedSelectQueryBuilder<T> Join(params Func<dynamic, object>[] func)
         {
             base.Join(func);

DynamORM/DynamicDatabase.cs

@@ -453,7 +453,31 @@ namespace DynamORM
         /// <param name="alias">Table alias.</param>
         /// <param name="noLock">use no lock.</param>
         /// <returns>This instance to permit chaining.</returns>
-        public virtual IDynamicTypedSelectQueryBuilder<T> From<T>(string alias = null, bool noLock = false)
+        public virtual IDynamicSelectQueryBuilder From<T>(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));
+            }
+        }
+        
+        /// <summary>Adds to the <code>FROM</code> clause using <see cref="Type"/>.</summary>
+        /// <typeparam name="T">Type which can be represented in database.</typeparam>
+        /// <param name="alias">Table alias.</param>
+        /// <param name="noLock">use no lock.</param>
+        /// <returns>This instance to permit chaining.</returns>
+        public virtual IDynamicTypedSelectQueryBuilder<T> FromTyped<T>(string alias = null, bool noLock = false)
         {
             // TODO: Make it more readable and maitainable
             DynamicTypedSelectQueryBuilder<T> builder = new DynamicTypedSelectQueryBuilder<T>(this);
@@ -503,7 +527,15 @@ namespace DynamORM
         /// <summary>Adds to the <code>INSERT INTO</code> clause using <see cref="Type"/>.</summary>
         /// <typeparam name="T">Type which can be represented in database.</typeparam>
         /// <returns>This instance to permit chaining.</returns>
-        public virtual IDynamicTypedInsertQueryBuilder<T> Insert<T>()
+        public virtual IDynamicInsertQueryBuilder Insert<T>()
+        {
+            return new DynamicInsertQueryBuilder(this).Table(typeof(T));
+        }
+        
+        /// <summary>Adds to the <code>INSERT INTO</code> clause using <see cref="Type"/>.</summary>
+        /// <typeparam name="T">Type which can be represented in database.</typeparam>
+        /// <returns>This instance to permit chaining.</returns>
+        public virtual IDynamicTypedInsertQueryBuilder<T> InsertTyped<T>()
         {
             DynamicTypedInsertQueryBuilder<T> builder = new DynamicTypedInsertQueryBuilder<T>(this);
             builder.Table(typeof(T));
@@ -612,7 +644,15 @@ namespace DynamORM
         /// <summary>Adds to the <code>UPDATE</code> clause using <see cref="Type"/>.</summary>
         /// <typeparam name="T">Type which can be represented in database.</typeparam>
         /// <returns>This instance to permit chaining.</returns>
-        public virtual IDynamicTypedUpdateQueryBuilder<T> Update<T>()
+        public virtual IDynamicUpdateQueryBuilder Update<T>()
+        {
+            return new DynamicUpdateQueryBuilder(this).Table(typeof(T));
+        }
+
+        /// <summary>Adds to the <code>UPDATE</code> clause using <see cref="Type"/>.</summary>
+        /// <typeparam name="T">Type which can be represented in database.</typeparam>
+        /// <returns>This instance to permit chaining.</returns>
+        public virtual IDynamicTypedUpdateQueryBuilder<T> UpdateTyped<T>()
         {
             DynamicTypedUpdateQueryBuilder<T> builder = new DynamicTypedUpdateQueryBuilder<T>(this);
             builder.Table(typeof(T));
@@ -835,7 +875,15 @@ namespace DynamORM
         /// <summary>Adds to the <code>DELETE FROM</code> clause using <see cref="Type"/>.</summary>
         /// <typeparam name="T">Type which can be represented in database.</typeparam>
         /// <returns>This instance to permit chaining.</returns>
-        public virtual IDynamicTypedDeleteQueryBuilder<T> Delete<T>()
+        public virtual IDynamicDeleteQueryBuilder Delete<T>()
+        {
+            return new DynamicDeleteQueryBuilder(this).Table(typeof(T));
+        }
+
+        /// <summary>Adds to the <code>DELETE FROM</code> clause using <see cref="Type"/>.</summary>
+        /// <typeparam name="T">Type which can be represented in database.</typeparam>
+        /// <returns>This instance to permit chaining.</returns>
+        public virtual IDynamicTypedDeleteQueryBuilder<T> DeleteTyped<T>()
         {
             DynamicTypedDeleteQueryBuilder<T> builder = new DynamicTypedDeleteQueryBuilder<T>(this);
             builder.Table(typeof(T));