Merge pull request #510 from sqlkata/feature/where-boolean

Delegate where(boolean) to WhereTrue/WhereFalse methods

Author: ahmad-moussawi

QueryBuilder.Tests/GeneralTests.cs

@@ -435,5 +435,61 @@ public void UnsafeLiteral_Update()
 
             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/ParameterTypeTests.cs

@@ -25,9 +25,9 @@ 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[] {"'2018-10-28 19:22:00'", new DateTime(2018, 10, 28, 19, 22, 0, DateTimeKind.Utc)},
+                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)},
                 new object[] {"0 /* First */", EnumExample.First},
                 new object[] {"1 /* Second */", EnumExample.Second},
                 new object[] {"'a string'", "a string"},

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/Base.Where.cs

@@ -18,6 +18,16 @@ public Q Where(string column, string op, object value)
                 return Not(op != "=").WhereNull(column);
             }
 
+            if (value is bool boolValue)
+            {
+                if (op != "=")
+                {
+                    Not();
+                }
+
+                return boolValue ? WhereTrue(column) : WhereFalse(column);
+            }
+
             return AddComponent("where", new BasicCondition
             {
                 Column = column,