Select improvements and alias parsing.

Insert and updates evolved.
Written more tests that intended to break parser.
Added basic exception handling, telling user what went wrong.

TODO:
 * INSERT INTO ... SELECT ...
 * Extend and normalize documentation.

DynamORM.Tests/Modify/ParserTests.cs

@@ -27,6 +27,7 @@
 */
 
 using System.Linq;
+using DynamORM.Builders;
 using DynamORM.Builders.Implementation;
 using NUnit.Framework;
 
@@ -55,13 +56,15 @@ namespace DynamORM.Tests.Modify
             DestroyTestDatabase();
         }
 
+        #region Insert
+
         /// <summary>
         /// Tests the basic insert.
         /// </summary>
         [Test]
-        public void TestBasicInsert()
+        public void TestInsertBasic()
         {
-            var cmd = new DynamicInsertQueryBuilder(Database, "Users");
+            IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
 
             cmd.Insert(x => x.Users.Code = "001", x => x.Users.Name = "Admin", x => x.Users.IsAdmin = 1);
 
@@ -75,7 +78,7 @@ namespace DynamORM.Tests.Modify
         [Test]
         public void TestInsertSubQuery()
         {
-            var cmd = new DynamicInsertQueryBuilder(Database, "Users");
+            IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
 
             cmd.Insert(x => x.Code = "001", x => x.Name = "Admin", x => x.IsAdmin = x(cmd
                 .SubQuery(a => a.AccessRights.As(a.a))
@@ -90,9 +93,9 @@ namespace DynamORM.Tests.Modify
         /// Tests the basic insert using object.
         /// </summary>
         [Test]
-        public void TestBasicInsertObject()
+        public void TestInsertBasicObject()
         {
-            var cmd = new DynamicInsertQueryBuilder(Database, "Users");
+            IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
 
             cmd.Insert(x => new { Code = "001", Name = "Admin", IsAdmin = 1 });
 
@@ -106,7 +109,7 @@ namespace DynamORM.Tests.Modify
         [Test]
         public void TestInsertSubQueryObject()
         {
-            var cmd = new DynamicInsertQueryBuilder(Database, "Users");
+            IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
 
             cmd.Insert(x => new
             {
@@ -121,5 +124,81 @@ namespace DynamORM.Tests.Modify
             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 TestUpdateBasic()
+        {
+            IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
+
+            cmd.Values(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 insert with sub query.
+        /// </summary>
+        [Test]
+        public void TestUpdateSubQuery()
+        {
+            IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
+
+            cmd.Values(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()
+        {
+            IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
+
+            cmd.Values(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()
+        {
+            IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
+
+            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 == 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/DynamicAccessTests.cs

@@ -436,29 +436,23 @@ namespace DynamORM.Tests.Select
             Assert.AreEqual(exp.last, o.last);
         }
 
-        /// <summary>Test dynamic duplicate column name ocurrance.</summary>
+        /// <summary>Test dynamic duplicate column name occurrence.</summary>
         [Test]
         public void TestDuplicateColumnNameException()
         {
             Assert.Throws<ArgumentException>(() => GetTestBuilder()
                 .Where(x => x.id == 19)
-                .Select(x => new { id = x.id, first = x.first, last = x.last })
+                .Select(x => new
+                {
+                    id = x.id,
+                    first = x.first,
+                    last = x.last,
+                })
                 .Select(x => x.last.As(x.first)) // Make last be first
                 .Execute()
                 .First());
         }
 
-        [Test]
-        public void TestEmptyColumnName()
-        {
-            var v = GetTestBuilder()
-                .Select(x => x.first, x => x.Count(x.first))
-                .GroupBy(x => x.first)
-                .OrderBy(x => x.Desc(2))
-                .Execute()
-                .ToList();
-        }
-
         #endregion Select
 
         #region Where

DynamORM.Tests/Select/ParserTests.cs

@@ -326,6 +326,21 @@ namespace DynamORM.Tests.Select
             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 left outer join method.
         /// </summary>
@@ -496,6 +511,20 @@ namespace DynamORM.Tests.Select
             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>