chore: merge upstream repo

.github/workflows/build.yml

@@ -30,6 +30,12 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
+      - name: Set env
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+      - name: Checking release
+        run: |
+          echo $RELEASE_VERSION
+          echo ${{ env.RELEASE_VERSION }}
       - name: Setup .NET Core
         uses: actions/setup-dotnet@v1
         with:
@@ -94,15 +100,15 @@ jobs:
           echo Version: $VERSION
           VERSION="${VERSION//v}"
           echo Clean Version: $VERSION
-          dotnet pack -v normal -c Release --include-symbols --include-source -p:PackageVersion=$VERSION -o nupkg QueryBuilder/QueryBuilder.csproj
+          dotnet pack -v normal -c Release --include-symbols --include-source -p:Version=$VERSION -p:PackageVersion=$VERSION -o nupkg QueryBuilder/QueryBuilder.csproj
       - name: Create Release NuGet package (SqlKata.Execution)
         run: |
           arrTag=(${GITHUB_REF//\// })
           VERSION="${arrTag[2]}"
           echo Version: $VERSION
           VERSION="${VERSION//v}"
           echo Clean Version: $VERSION
-          dotnet pack -v normal -c Release --include-symbols --include-source -p:PackageVersion=$VERSION -o nupkg SqlKata.Execution/SqlKata.Execution.csproj
+          dotnet pack -v normal -c Release --include-symbols --include-source -p:Version=$VERSION -p:PackageVersion=$VERSION -o nupkg SqlKata.Execution/SqlKata.Execution.csproj
       - name: Push to GitHub Feed
         run: dotnet nuget push ./nupkg/*.nupkg --skip-duplicate --source $GITHUB_FEED --api-key $GITHUB_TOKEN
       - name: Push to NuGet Feed

QueryBuilder.Tests/Firebird/FirebirdLimitTests.cs

@@ -52,4 +52,4 @@ public void LimitAndOffset()
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
-}
+}

QueryBuilder.Tests/GeneralTests.cs

@@ -401,5 +401,195 @@ public void Where_Nested()
 
             Assert.Equal("SELECT * FROM [table] WHERE ([a] = 1 OR [a] = 2)", c[EngineCodes.SqlServer].ToString());
         }
+
+        [Fact]
+        public void AdHoc_Throws_WhenNoColumnsProvided() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new string[0],
+                    new object[][] {
+                        new object[] {},
+                        new object[] {},
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenNoValueRowsProvided() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b", "c" },
+                    new object[][] {
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenColumnsOutnumberFieldValues() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b", "c", "d" },
+                    new object[][] {
+                        new object[] { 1, 2, 3 },
+                        new object[] { 4, 5, 6 },
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenFieldValuesOutNumberColumns() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b" },
+                    new object[][] {
+                        new object[] { 1, 2, 3 },
+                        new object[] { 4, 5, 6 },
+                    }));
+
+        [Fact]
+        public void AdHoc_SingletonRow()
+        {
+            var query = new Query("rows").With("rows",
+                new[] { "a" },
+                new object[][] {
+                    new object[] { 1 },
+                });
+
+            var c = Compilers.Compile(query);
+
+            Assert.Equal("WITH [rows] AS (SELECT [a] FROM (VALUES (1)) AS tbl ([a]))\nSELECT * FROM [rows]", c[EngineCodes.SqlServer].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\")\nSELECT * FROM \"rows\"", c[EngineCodes.PostgreSql].ToString());
+            Assert.Equal("WITH `rows` AS (SELECT 1 AS `a`)\nSELECT * FROM `rows`", c[EngineCodes.MySql].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\")\nSELECT * FROM \"rows\"", c[EngineCodes.Sqlite].ToString());
+            Assert.Equal("WITH \"ROWS\" AS (SELECT 1 AS \"A\" FROM RDB$DATABASE)\nSELECT * FROM \"ROWS\"", c[EngineCodes.Firebird].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\" FROM DUAL)\nSELECT * FROM \"rows\"", c[EngineCodes.Oracle].ToString());
+        }
+
+        [Fact]
+        public void AdHoc_TwoRows()
+        {
+            var query = new Query("rows").With("rows",
+                new[] { "a", "b", "c" },
+                new object[][] {
+                    new object[] { 1, 2, 3 },
+                    new object[] { 4, 5, 6 },
+                });
+
+            var c = Compilers.Compile(query);
+
+            Assert.Equal("WITH [rows] AS (SELECT [a], [b], [c] FROM (VALUES (1, 2, 3), (4, 5, 6)) AS tbl ([a], [b], [c]))\nSELECT * FROM [rows]", c[EngineCodes.SqlServer].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\", 2 AS \"b\", 3 AS \"c\" UNION ALL SELECT 4 AS \"a\", 5 AS \"b\", 6 AS \"c\")\nSELECT * FROM \"rows\"", c[EngineCodes.PostgreSql].ToString());
+            Assert.Equal("WITH `rows` AS (SELECT 1 AS `a`, 2 AS `b`, 3 AS `c` UNION ALL SELECT 4 AS `a`, 5 AS `b`, 6 AS `c`)\nSELECT * FROM `rows`", c[EngineCodes.MySql].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\", 2 AS \"b\", 3 AS \"c\" UNION ALL SELECT 4 AS \"a\", 5 AS \"b\", 6 AS \"c\")\nSELECT * FROM \"rows\"", c[EngineCodes.Sqlite].ToString());
+            Assert.Equal("WITH \"ROWS\" AS (SELECT 1 AS \"A\", 2 AS \"B\", 3 AS \"C\" FROM RDB$DATABASE UNION ALL SELECT 4 AS \"A\", 5 AS \"B\", 6 AS \"C\" FROM RDB$DATABASE)\nSELECT * FROM \"ROWS\"", c[EngineCodes.Firebird].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS \"a\", 2 AS \"b\", 3 AS \"c\" FROM DUAL UNION ALL SELECT 4 AS \"a\", 5 AS \"b\", 6 AS \"c\" FROM DUAL)\nSELECT * FROM \"rows\"", c[EngineCodes.Oracle].ToString());
+        }
+
+        [Fact]
+        public void AdHoc_ProperBindingsPlacement()
+        {
+            var query = new Query("rows")
+                .With("othercte", q => q.From("othertable").Where("othertable.status", "A"))
+                .Where("rows.foo", "bar")
+                .With("rows",
+                new[] { "a", "b", "c" },
+                new object[][] {
+                    new object[] { 1, 2, 3 },
+                    new object[] { 4, 5, 6 },
+                })
+                .Where("rows.baz", "buzz");
+
+            var c = Compilers.Compile(query);
+
+            Assert.Equal(string.Join("\n", new[] {
+                "WITH [othercte] AS (SELECT * FROM [othertable] WHERE [othertable].[status] = 'A'),",
+                "[rows] AS (SELECT [a], [b], [c] FROM (VALUES (1, 2, 3), (4, 5, 6)) AS tbl ([a], [b], [c]))",
+                "SELECT * FROM [rows] WHERE [rows].[foo] = 'bar' AND [rows].[baz] = 'buzz'",
+            }), c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void UnsafeLiteral_Insert()
+        {
+            var query = new Query("Table").AsInsert(new
+            {
+                Count = new UnsafeLiteral("Count + 1")
+            });
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("INSERT INTO [Table] ([Count]) VALUES (Count + 1)", c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void UnsafeLiteral_Update()
+        {
+            var query = new Query("Table").AsUpdate(new
+            {
+                Count = new UnsafeLiteral("Count + 1")
+            });
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("UPDATE [Table] SET [Count] = Count + 1", c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void Passing_Boolean_To_Where_Should_Call_WhereTrue_Or_WhereFalse()
+        {
+            var query = new Query("Table").Where("Col", true);
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("SELECT * FROM [Table] WHERE [Col] = cast(1 as bit)", c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void Passing_Boolean_False_To_Where_Should_Call_WhereTrue_Or_WhereFalse()
+        {
+            var query = new Query("Table").Where("Col", false);
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("SELECT * FROM [Table] WHERE [Col] = cast(0 as bit)", c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void Passing_Negative_Boolean_To_Where_Should_Call_WhereTrue_Or_WhereFalse()
+        {
+            var query = new Query("Table").Where("Col", "!=", true);
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("SELECT * FROM [Table] WHERE [Col] != cast(1 as bit)", c[EngineCodes.SqlServer].ToString());
+        }
+
+        [Fact]
+        public void Passing_Negative_Boolean_False_To_Where_Should_Call_WhereTrue_Or_WhereFalse()
+        {
+            var query = new Query("Table").Where("Col", "!=", false);
+
+            var engines = new[] {
+                EngineCodes.SqlServer,
+            };
+
+            var c = Compilers.Compile(engines, query);
+
+            Assert.Equal("SELECT * FROM [Table] WHERE [Col] != cast(0 as bit)", c[EngineCodes.SqlServer].ToString());
+        }
     }
 }

QueryBuilder.Tests/MySql/MySqlLimitTests.cs

@@ -55,4 +55,4 @@ public void WithLimitAndOffset()
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
-}
+}

QueryBuilder.Tests/ParameterTypeTests.cs

@@ -25,8 +25,8 @@ public class ParameterTypeGenerator : IEnumerable<object[]>
                 new object[] {Convert.ToSingle("10.5", CultureInfo.InvariantCulture).ToString(), 10.5},
                 new object[] {"-2", -2},
                 new object[] {Convert.ToSingle("-2.8", CultureInfo.InvariantCulture).ToString(), -2.8},
-                new object[] {"true", true},
-                new object[] {"false", false},
+                new object[] {"cast(1 as bit)", true},
+                new object[] {"cast(0 as bit)", false},
                 new object[] {"'2018-10-28 19:22:00'", new DateTime(2018, 10, 28, 19, 22, 0, DateTimeKind.Utc)},
                 new object[] {"0 /* First */", EnumExample.First},
                 new object[] {"1 /* Second */", EnumExample.Second},
@@ -49,4 +49,4 @@ public void CorrectParameterTypeOutput(string rendered, object input)
             Assert.Equal($"SELECT * FROM [Table] WHERE [Col] = {rendered}", c[EngineCodes.SqlServer]);
         }
     }
-}
+}

QueryBuilder.Tests/PostgreSql/PostgreSqlLimitTests.cs

@@ -55,4 +55,4 @@ public void WithLimitAndOffset()
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
-}
+}

QueryBuilder.Tests/SelectTests.cs

@@ -1,7 +1,8 @@
-using SqlKata.Compilers;
+using SqlKata.Compilers;
 using SqlKata.Extensions;
 using SqlKata.Tests.Infrastructure;
 using System;
+using System.Collections.Generic;
 using Xunit;
 
 namespace SqlKata.Tests
@@ -21,6 +22,20 @@ public void BasicSelect()
             Assert.Equal("SELECT \"id\", \"name\" FROM \"users\"", c[EngineCodes.Oracle]);
         }
 
+        [Fact]
+        public void BasicSelectEnumerable()
+        {
+            var q = new Query().From("users").Select(new List<string>() { "id", "name" });
+            var c = Compile(q);
+
+            Assert.Equal("SELECT [id], [name] FROM [users]", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT `id`, `name` FROM `users`", c[EngineCodes.MySql]);
+            Assert.Equal("SELECT \"id\", \"name\" FROM \"users\"", c[EngineCodes.PostgreSql]);
+            Assert.Equal("SELECT \"ID\", \"NAME\" FROM \"USERS\"", c[EngineCodes.Firebird]);
+            Assert.Equal("SELECT \"id\", \"name\" FROM \"users\"", c[EngineCodes.Oracle]);
+        }
+
+
         [Fact]
         public void SelectAs()
         {

QueryBuilder.Tests/SqlServer/NestedSelectTests.cs

@@ -56,7 +56,7 @@ public void SqlCompile_QueryLimitAndNestedLimit_BindingValue()
             // var q = new Query().From("Foo").Where("C", "c").WhereExists(n).Where("A", "a");
 
             var actual = compiler.Compile(q).ToString();
-            Assert.Contains("SELECT * FROM [Foo] WHERE [x] = true AND NOT EXISTS (SELECT 1 FROM [Bar])",
+            Assert.Contains("SELECT * FROM [Foo] WHERE [x] = cast(1 as bit) AND NOT EXISTS (SELECT 1 FROM [Bar])",
                 actual);
             // Assert.Contains("SELECT * FROM [Foo] WHERE [C] = 'c' AND EXISTS (SELECT TOP (1) 1 FROM [Bar]) AND [A] = 'a'", actual);
         }

QueryBuilder.Tests/SqlServer/SqlServerLegacyLimitTests.cs

@@ -75,4 +75,4 @@ public void ShouldKeepTheOrdersAsIsIfPaginationProvided()
             Assert.DoesNotContain("(SELECT 0)", compiler.Compile(query).ToString());
         }
     }
-}
+}

QueryBuilder.Tests/SqlServer/SqlServerLimitTests.cs

@@ -85,4 +85,4 @@ public void ShouldKeepTheOrdersAsIsIfPaginationProvided()
             Assert.DoesNotContain("(SELECT 0)", compiler.Compile(query).ToString());
         }
     }
-}
+}

QueryBuilder.Tests/UpdateTests.cs

@@ -283,5 +283,37 @@ public void UpdateUsingExpandoObject()
                 "UPDATE [Table] SET [Name] = 'The User', [Age] = '2018-01-01'",
                 c[EngineCodes.SqlServer]);
         }
+
+        [Fact]
+        public void IncrementUpdate()
+        {
+            var query = new Query("Table").AsIncrement("Total");
+            var c = Compile(query);
+            Assert.Equal("UPDATE [Table] SET [Total] = [Total] + 1", c[EngineCodes.SqlServer]);
+        }
+
+        [Fact]
+        public void IncrementUpdateWithValue()
+        {
+            var query = new Query("Table").AsIncrement("Total", 2);
+            var c = Compile(query);
+            Assert.Equal("UPDATE [Table] SET [Total] = [Total] + 2", c[EngineCodes.SqlServer]);
+        }
+
+        [Fact]
+        public void IncrementUpdateWithWheres()
+        {
+            var query = new Query("Table").Where("Name", "A").AsIncrement("Total", 2);
+            var c = Compile(query);
+            Assert.Equal("UPDATE [Table] SET [Total] = [Total] + 2 WHERE [Name] = 'A'", c[EngineCodes.SqlServer]);
+        }
+
+        [Fact]
+        public void DecrementUpdate()
+        {
+            var query = new Query("Table").Where("Name", "A").AsDecrement("Total", 2);
+            var c = Compile(query);
+            Assert.Equal("UPDATE [Table] SET [Total] = [Total] - 2 WHERE [Name] = 'A'", c[EngineCodes.SqlServer]);
+        }
     }
 }

QueryBuilder.Tests/WhereTests.cs

@@ -0,0 +1,33 @@
+using SqlKata.Compilers;
+using SqlKata.Tests.Infrastructure;
+using Xunit;
+
+namespace SqlKata.Tests
+{
+    public class WhereTests : TestSupport
+    {
+        [Fact]
+        public void GroupedWhereFilters()
+        {
+            var q = new Query("Table1")
+                .Where(q => q.Or().Where("Column1", 10).Or().Where("Column2", 20))
+                .Where("Column3", 30);
+
+            var c = Compile(q);
+
+            Assert.Equal(@"SELECT * FROM ""Table1"" WHERE (""Column1"" = 10 OR ""Column2"" = 20) AND ""Column3"" = 30", c[EngineCodes.PostgreSql]);
+        }
+
+        [Fact]
+        public void GroupedHavingFilters()
+        {
+            var q = new Query("Table1")
+                .Having(q => q.Or().HavingRaw("SUM([Column1]) = ?", 10).Or().HavingRaw("SUM([Column2]) = ?", 20))
+                .HavingRaw("SUM([Column3]) = ?", 30);
+
+            var c = Compile(q);
+
+            Assert.Equal(@"SELECT * FROM ""Table1"" HAVING (SUM(""Column1"") = 10 OR SUM(""Column2"") = 20) AND SUM(""Column3"") = 30", c[EngineCodes.PostgreSql]);
+        }
+    }
+}