diff --git a/AmalgamationTool/DynamORM.Amalgamation.cs b/AmalgamationTool/DynamORM.Amalgamation.cs
index 73602bb..39740b5 100644
--- a/AmalgamationTool/DynamORM.Amalgamation.cs
+++ b/AmalgamationTool/DynamORM.Amalgamation.cs
@@ -1932,7 +1932,30 @@ 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);
@@ -1978,11 +2001,16 @@ 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>()
         {
-            DynamicTypedInsertQueryBuilder<T> builder = new DynamicTypedInsertQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
+            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>()
+        {
+            return new DynamicTypedInsertQueryBuilder<T>(this, true);
         }
         /// <summary>Adds to the <code>INSERT INTO</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>
@@ -2080,11 +2108,16 @@ 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>()
         {
-            DynamicTypedUpdateQueryBuilder<T> builder = new DynamicTypedUpdateQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
+            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>()
+        {
+            return new DynamicTypedUpdateQueryBuilder<T>(this, true);
         }
         /// <summary>Adds to the <code>UPDATE</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>
@@ -2291,11 +2324,16 @@ 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>()
         {
-            DynamicTypedDeleteQueryBuilder<T> builder = new DynamicTypedDeleteQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
+            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>()
+        {
+            return new DynamicTypedDeleteQueryBuilder<T>(this, true);
         }
         /// <summary>Adds to the <code>DELETE FROM</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>
@@ -7210,18 +7248,6 @@ namespace DynamORM
                 /// <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>
@@ -10636,8 +10662,16 @@ namespace DynamORM
                 internal class DynamicTypedDeleteQueryBuilder<T> : DynamicDeleteQueryBuilder, IDynamicTypedDeleteQueryBuilder<T>
                 {
                     internal DynamicTypedDeleteQueryBuilder(DynamicDatabase db)
+                        : this(db, false)
+                    {
+                    }
+                    internal DynamicTypedDeleteQueryBuilder(DynamicDatabase db, bool mapType)
                         : base(db)
                     {
+                        if (mapType)
+                            this.Table(typeof(T));
+                        else
+                            this.Table(typeof(T).Name);
                     }
                     public IDynamicTypedDeleteQueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
                     {
@@ -10675,8 +10709,16 @@ namespace DynamORM
                 internal class DynamicTypedInsertQueryBuilder<T> : DynamicInsertQueryBuilder, IDynamicTypedInsertQueryBuilder<T>
                 {
                     internal DynamicTypedInsertQueryBuilder(DynamicDatabase db)
+                        : this(db, false)
+                    {
+                    }
+                    internal DynamicTypedInsertQueryBuilder(DynamicDatabase db, bool mapType)
                         : base(db)
                     {
+                        if (mapType)
+                            this.Table(typeof(T));
+                        else
+                            this.Table(typeof(T).Name);
                     }
                     public IDynamicTypedInsertQueryBuilder<T> Insert<TValue>(Expression<Func<T, TValue>> selector, object value)
                     {
@@ -10810,22 +10852,6 @@ namespace DynamORM
                         AppendJoinClause(joinExpr);
                         return this;
                     }
-                    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);
@@ -11363,8 +11389,16 @@ namespace DynamORM
                 internal class DynamicTypedUpdateQueryBuilder<T> : DynamicUpdateQueryBuilder, IDynamicTypedUpdateQueryBuilder<T>
                 {
                     internal DynamicTypedUpdateQueryBuilder(DynamicDatabase db)
+                        : this(db, false)
+                    {
+                    }
+                    internal DynamicTypedUpdateQueryBuilder(DynamicDatabase db, bool mapType)
                         : base(db)
                     {
+                        if (mapType)
+                            this.Table(typeof(T));
+                        else
+                            this.Table(typeof(T).Name);
                     }
                     public IDynamicTypedUpdateQueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
                     {
diff --git a/DynamORM.Tests/Select/TypedFluentBuilderTests.cs b/DynamORM.Tests/Select/TypedFluentBuilderTests.cs
index 84ff65a..d479c38 100644
--- a/DynamORM.Tests/Select/TypedFluentBuilderTests.cs
+++ b/DynamORM.Tests/Select/TypedFluentBuilderTests.cs
@@ -121,7 +121,7 @@ namespace DynamORM.Tests.Select
         public void TestTypedRightJoin()
         {
             var cmd = Database.FromTyped<TypedFluentUser>("u")
-                .Join<TypedFluentUser>(j => j.Right().As("X").On((l, r) => l.Id == r.Id))
+                .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,7 +132,7 @@ namespace DynamORM.Tests.Select
         public void TestTypedFullJoin()
         {
             var cmd = Database.FromTyped<TypedFluentUser>("u")
-                .Join<TypedFluentUser>(j => j.Full().As("X").On((l, r) => l.Id == r.Id))
+                .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\")",
diff --git a/DynamORM.Tests/Select/TypedFluentJoinSyntaxTests.cs b/DynamORM.Tests/Select/TypedFluentJoinSyntaxTests.cs
index 4c29f68..d11945a 100644
--- a/DynamORM.Tests/Select/TypedFluentJoinSyntaxTests.cs
+++ b/DynamORM.Tests/Select/TypedFluentJoinSyntaxTests.cs
@@ -33,7 +33,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedJoinDefaultJoinKeyword()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.As("uc").On((u, c) => u.IdUser == c.UserId));
 
             Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS usr JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")", cmd.CommandText());
@@ -42,7 +42,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedInnerJoinWithAndNull()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.Inner().As("uc").On((u, c) => u.IdUser == c.UserId && c.Users != null))
                 .Select(u => u.IdUser);
 
@@ -52,7 +52,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedJoinWithNoLock()
         {
-            var cmd = Database.From<TypedJoinUser>("usr", noLock: true)
+            var cmd = Database.FromTyped<TypedJoinUser>("usr", noLock: true)
                 .Join<TypedJoinUserClient>(j => j.Inner().As("uc").NoLock().On((u, c) => u.IdUser == c.UserId));
 
             Assert.AreEqual("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());
@@ -61,7 +61,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedLeftOuterJoin()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.LeftOuter().As("uc").On((u, c) => u.IdUser == c.UserId));
 
             Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS usr LEFT OUTER JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")", cmd.CommandText());
@@ -70,7 +70,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedRightOuterJoin()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.RightOuter().As("uc").On((u, c) => u.IdUser == c.UserId));
 
             Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS usr RIGHT OUTER JOIN \"dbo\".\"UserClients\" AS uc ON (usr.\"Id_User\" = uc.\"User_Id\")", cmd.CommandText());
@@ -79,7 +79,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedCustomJoinTypeCrossApply()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.Type("CROSS APPLY").As("uc"));
 
             Assert.AreEqual("SELECT * FROM \"dbo\".\"Users\" AS usr CROSS APPLY \"dbo\".\"UserClients\" AS uc", cmd.CommandText());
@@ -88,7 +88,7 @@ namespace DynamORM.Tests.Select
         [Test]
         public void TestTypedJoinAndWhereParameterOrder()
         {
-            var cmd = Database.From<TypedJoinUser>("usr")
+            var cmd = Database.FromTyped<TypedJoinUser>("usr")
                 .Join<TypedJoinUserClient>(j => j.As("uc").On((u, c) => u.IdUser == c.UserId && c.Deleted == 0))
                 .Where(u => u.Active == 1);
 
diff --git a/DynamORM/Builders/Implementation/DynamicTypedDeleteQueryBuilder.cs b/DynamORM/Builders/Implementation/DynamicTypedDeleteQueryBuilder.cs
index eddbd13..f475f95 100644
--- a/DynamORM/Builders/Implementation/DynamicTypedDeleteQueryBuilder.cs
+++ b/DynamORM/Builders/Implementation/DynamicTypedDeleteQueryBuilder.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Linq.Expressions;
+using DynamORM.Builders.Extensions;
 
 namespace DynamORM.Builders.Implementation
 {
@@ -14,8 +15,17 @@ namespace DynamORM.Builders.Implementation
     internal class DynamicTypedDeleteQueryBuilder<T> : DynamicDeleteQueryBuilder, IDynamicTypedDeleteQueryBuilder<T>
     {
         internal DynamicTypedDeleteQueryBuilder(DynamicDatabase db)
+            : this(db, false)
+        {
+        }
+
+        internal DynamicTypedDeleteQueryBuilder(DynamicDatabase db, bool mapType)
             : base(db)
         {
+            if (mapType)
+                this.Table(typeof(T));
+            else
+                this.Table(typeof(T).Name);
         }
 
         public IDynamicTypedDeleteQueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
diff --git a/DynamORM/Builders/Implementation/DynamicTypedInsertQueryBuilder.cs b/DynamORM/Builders/Implementation/DynamicTypedInsertQueryBuilder.cs
index 257f7ee..2ae6ee1 100644
--- a/DynamORM/Builders/Implementation/DynamicTypedInsertQueryBuilder.cs
+++ b/DynamORM/Builders/Implementation/DynamicTypedInsertQueryBuilder.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Linq.Expressions;
+using DynamORM.Builders.Extensions;
 
 namespace DynamORM.Builders.Implementation
 {
@@ -14,8 +15,17 @@ namespace DynamORM.Builders.Implementation
     internal class DynamicTypedInsertQueryBuilder<T> : DynamicInsertQueryBuilder, IDynamicTypedInsertQueryBuilder<T>
     {
         internal DynamicTypedInsertQueryBuilder(DynamicDatabase db)
+            : this(db, false)
+        {
+        }
+
+        internal DynamicTypedInsertQueryBuilder(DynamicDatabase db, bool mapType)
             : base(db)
         {
+            if (mapType)
+                this.Table(typeof(T));
+            else
+                this.Table(typeof(T).Name);
         }
 
         public IDynamicTypedInsertQueryBuilder<T> Insert<TValue>(Expression<Func<T, TValue>> selector, object value)
diff --git a/DynamORM/Builders/Implementation/DynamicTypedUpdateQueryBuilder.cs b/DynamORM/Builders/Implementation/DynamicTypedUpdateQueryBuilder.cs
index efa2c26..6b6720d 100644
--- a/DynamORM/Builders/Implementation/DynamicTypedUpdateQueryBuilder.cs
+++ b/DynamORM/Builders/Implementation/DynamicTypedUpdateQueryBuilder.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Linq.Expressions;
+using DynamORM.Builders.Extensions;
 
 namespace DynamORM.Builders.Implementation
 {
@@ -14,8 +15,17 @@ namespace DynamORM.Builders.Implementation
     internal class DynamicTypedUpdateQueryBuilder<T> : DynamicUpdateQueryBuilder, IDynamicTypedUpdateQueryBuilder<T>
     {
         internal DynamicTypedUpdateQueryBuilder(DynamicDatabase db)
+            : this(db, false)
+        {
+        }
+
+        internal DynamicTypedUpdateQueryBuilder(DynamicDatabase db, bool mapType)
             : base(db)
         {
+            if (mapType)
+                this.Table(typeof(T));
+            else
+                this.Table(typeof(T).Name);
         }
 
         public IDynamicTypedUpdateQueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
diff --git a/DynamORM/DynamicDatabase.cs b/DynamORM/DynamicDatabase.cs
index a6e1250..83b4e9b 100644
--- a/DynamORM/DynamicDatabase.cs
+++ b/DynamORM/DynamicDatabase.cs
@@ -535,12 +535,10 @@ 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> InsertTyped<T>()
-        {
-            DynamicTypedInsertQueryBuilder<T> builder = new DynamicTypedInsertQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
-        }
+        public virtual IDynamicTypedInsertQueryBuilder<T> InsertTyped<T>()
+        {
+            return new DynamicTypedInsertQueryBuilder<T>(this, true);
+        }
 
         /// <summary>Adds to the <code>INSERT INTO</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>
@@ -652,12 +650,10 @@ 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> UpdateTyped<T>()
-        {
-            DynamicTypedUpdateQueryBuilder<T> builder = new DynamicTypedUpdateQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
-        }
+        public virtual IDynamicTypedUpdateQueryBuilder<T> UpdateTyped<T>()
+        {
+            return new DynamicTypedUpdateQueryBuilder<T>(this, true);
+        }
 
         /// <summary>Adds to the <code>UPDATE</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>
@@ -883,12 +879,10 @@ 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> DeleteTyped<T>()
-        {
-            DynamicTypedDeleteQueryBuilder<T> builder = new DynamicTypedDeleteQueryBuilder<T>(this);
-            builder.Table(typeof(T));
-            return builder;
-        }
+        public virtual IDynamicTypedDeleteQueryBuilder<T> DeleteTyped<T>()
+        {
+            return new DynamicTypedDeleteQueryBuilder<T>(this, true);
+        }
 
         /// <summary>Adds to the <code>DELETE FROM</code> clause using <see cref="Type"/>.</summary>
         /// <param name="t">Type which can be represented in database.</param>