Merge pull request #509 from shift-evgeny/WhereBooleanSupport

Handle expressions that evaluate to true/false/nulls in Where() expression

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -14,6 +14,9 @@ namespace ServiceStack.OrmLite
 {
     public abstract partial class SqlExpression<T> : ISqlExpression, IHasUntypedSqlExpression
     {
+        private const string TrueLiteral = "(1=1)";
+        private const string FalseLiteral = "(1=0)";
+
         protected bool visitedExpressionIsTableColumn = false;
         protected bool skipParameterizationForThisExpression = false;
 
@@ -421,10 +424,17 @@ protected void AppendToWhere(string condition, Expression predicate)
 
             useFieldName = true;
             sep = " ";
-            var newExpr = Visit(predicate).ToString();
+            var newExpr = WhereExpressionToString(Visit(predicate));
             AppendToWhere(condition, newExpr);
         }
 
+        private static string WhereExpressionToString(object expression)
+        {
+            if (expression is bool)
+                return (bool)expression ? TrueLiteral : FalseLiteral;
+            return expression.ToString();
+        }
+
         protected void AppendToWhere(string condition, string sqlExpression)
         {
             whereExpression = string.IsNullOrEmpty(whereExpression)
@@ -1258,6 +1268,24 @@ protected virtual object VisitBinary(BinaryExpression b)
                 originalLeft = left = Visit(b.Left);
                 originalRight = right = Visit(b.Right);
 
+                // Handle "expr = true/false", including with the constant on the left
+
+                if (operand == "=" || operand == "<>")
+                {
+                    if (left is bool)
+                    {
+                        Swap(ref left, ref right); // Should be safe to swap for equality/inequality checks
+                    }
+
+                    if (right is bool && !IsFieldName(left)) // Don't change anything when "expr" is a column name - then we really want "ColName = 1"
+                    {
+                        if (operand == "=")
+                            return (bool)right ? left : GetNotValue(left); // "expr == true" becomes "expr", "expr == false" becomes "not (expr)"
+                        if (operand == "<>")
+                            return (bool)right ? GetNotValue(left) : left; // "expr != true" becomes "not (expr)", "expr != false" becomes "expr"
+                    }
+                }
+
                 var leftEnum = left as EnumMemberAccess;
                 var rightEnum = right as EnumMemberAccess;
 
@@ -1282,7 +1310,8 @@ protected virtual object VisitBinary(BinaryExpression b)
                 }
                 else if (left as PartialSqlString == null && right as PartialSqlString == null)
                 {
-                    var result = CachedExpressionCompiler.Evaluate(b);
+                    var evaluatedValue = CachedExpressionCompiler.Evaluate(b);
+                    var result = VisitConstant(Expression.Constant(evaluatedValue));
                     return result;
                 }
                 else if (left as PartialSqlString == null)
@@ -1297,10 +1326,7 @@ protected virtual object VisitBinary(BinaryExpression b)
 
             if (left.ToString().Equals("null", StringComparison.OrdinalIgnoreCase))
             {
-                // "null is x" will not work, so swap the operands
-                var temp = right;
-                right = left;
-                left = temp;
+                Swap(ref left, ref right); // "null is x" will not work, so swap the operands
             }
 
             if (operand == "=" && right.ToString().Equals("null", StringComparison.OrdinalIgnoreCase))
@@ -1320,6 +1346,13 @@ protected virtual object VisitBinary(BinaryExpression b)
             }
         }
 
+        private static void Swap(ref object left, ref object right)
+        {
+            var temp = right;
+            right = left;
+            left = temp;
+        }
+
         protected virtual void VisitFilter(string operand, object originalLeft, object originalRight, ref object left, ref object right)
         {
             if (skipParameterizationForThisExpression || visitedExpressionIsTableColumn)
@@ -1441,14 +1474,7 @@ protected virtual object VisitUnary(UnaryExpression u)
             {
                 case ExpressionType.Not:
                     var o = Visit(u.Operand);
-
-                    if (o as PartialSqlString == null)
-                        return !((bool)o);
-
-                    if (IsFieldName(o))
-                        return new PartialSqlString(o + "=" + GetQuotedFalseValue());
-
-                    return new PartialSqlString("NOT (" + o + ")");
+                    return GetNotValue(o);
                 case ExpressionType.Convert:
                     if (u.Method != null)
                     {
@@ -1459,6 +1485,17 @@ protected virtual object VisitUnary(UnaryExpression u)
             return Visit(u.Operand);
         }
 
+        private object GetNotValue(object o)
+        {
+            if (o as PartialSqlString == null)
+                return !((bool) o);
+
+            if (IsFieldName(o))
+                return new PartialSqlString(o + "=" + GetQuotedFalseValue());
+
+            return new PartialSqlString("NOT (" + o + ")");
+        }
+
         private bool IsColumnAccess(MethodCallExpression m)
         {
             if (m.Object != null && m.Object as MethodCallExpression != null)
@@ -1783,14 +1820,14 @@ protected string ConvertInExpressionToSql(MethodCallExpression m, object quotedC
             var argValue = CachedExpressionCompiler.Evaluate(m.Arguments[1]);
 
             if (argValue == null)
-                return "(1=0)"; // "column IN (NULL)" is always false
+                return FalseLiteral; // "column IN (NULL)" is always false
 
             var enumerableArg = argValue as IEnumerable;
             if (enumerableArg != null)
             {
                 var inArgs = Sql.Flatten(enumerableArg);
                 if (inArgs.Count == 0)
-                    return "(1=0)"; // "column IN ([])" is always false
+                    return FalseLiteral; // "column IN ([])" is always false
 
                 string sqlIn = CreateInParamSql(inArgs);
                 return string.Format("{0} {1} ({2})", quotedColName, m.Method.Name, sqlIn);

tests/ServiceStack.OrmLite.Tests/ExpressionVisitorTests.cs

@@ -272,6 +272,72 @@ public void Can_Select_using_int_Array_Contains()
             Assert.AreEqual(sql1, sql2);
         }
 
+        [Test]
+        public void Can_Select_using_boolean_constant()
+        {
+            var q = Db.From<TestType>().Where(x => true);
+            var target = Db.Select(q);
+            Assert.AreEqual(4, target.Count);
+
+            q = Db.From<TestType>().Where(x => false);
+            target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Select_using_expression_evaluated_to_constant()
+        {
+            var a = 5;
+            var b = 6;
+            int? nullableInt = null;
+
+            var q = Db.From<TestType>().Where(x => a < b); // "a < b" is evaluated by SqlExpression (not at compile time!) to ConstantExpression (true)
+            var target = Db.Select(q);
+            Assert.AreEqual(4, target.Count);
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol == nullableInt); // Expression evaluated to "null" in SqlExpression
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 2 }, target.Select(t => t.Id).ToArray());
+
+            q = Db.From<TestType>().Where(x => nullableInt == x.NullableIntCol); // Same with the null on the left
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 2 }, target.Select(t => t.Id).ToArray());
+
+            // Expression = or <> true or false
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol.HasValue == 5 < 6); // Evaluated to "true" at compile time: equivalent to "x.NullableIntCol != null"
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 3, 4 }, target.Select(t => t.Id).ToArray());
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol.HasValue == 5 > 6); // Evaluated to "false" at compile time: equivalent to "x.NullableIntCol == null"
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 2 }, target.Select(t => t.Id).ToArray());
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol.HasValue != 5 > 6); // != false
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 3, 4 }, target.Select(t => t.Id).ToArray());
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol.HasValue != 5 < 6); // != true
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 2 }, target.Select(t => t.Id).ToArray());
+
+            // Same, but with the constant on the left
+
+            q = Db.From<TestType>().Where(x => 5 < 6 == x.NullableIntCol.HasValue);
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 3, 4 }, target.Select(t => t.Id).ToArray());
+
+            q = Db.From<TestType>().Where(x => 5 > 6 != x.NullableIntCol.HasValue);
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 3, 4 }, target.Select(t => t.Id).ToArray());
+
+            // Same, but with the expression evaluated inside SqlExpression (not at compile time)
+
+            q = Db.From<TestType>().Where(x => x.NullableIntCol.HasValue == a < b);
+            target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 3, 4 }, target.Select(t => t.Id).ToArray());
+        }
+
         private int MethodReturningInt(int val)
         {
             return val;