Fix for CustomSqlExpression with virtual boolean properties. (#619)

* Support for Conditional expression in filter

* Fixes for conditional expressions in filter and sorting

* Using GetFieldValue in InsertOnly just like in Insert.

* Change SqliteBoolConverter DbType to Int32

* Unit test for SqliteBoolConverter, InsertOnly

* Fix for parsing static method inside non-static method.

* Just formatting

* Change access modifier to public for method "IsSqlClass"

* Add support for using the Length property of String

* VisitLengthStringProperty fix for CustomSqlExpression

* Fix for CustomSqlExpression with virtual boolean properties.

Author: OlegNadymov

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1576,6 +1576,15 @@ protected virtual object VisitBinary(BinaryExpression b)
                         Swap(ref left, ref right); // Should be safe to swap for equality/inequality checks
                     }
 
+                    if (right is bool &&
+                        (left == null || left.ToString().Equals("null", StringComparison.OrdinalIgnoreCase)))
+                    {
+                        if (operand == "=")
+                            return false; // "null == true/false" becomes "false"
+                        if (operand == "<>")
+                            return true; // "null != true/false" becomes "true"
+                    }
+
                     if (right is bool && !IsFieldName(left) && !(b.Left is ConditionalExpression)) // Don't change anything when "expr" is a column name or ConditionalExpression - then we really want "ColName = 1" or (Case When 1=0 Then 1 Else 0 End = 1)
                     {
                         if (operand == "=")

tests/ServiceStack.OrmLite.Tests/CustomSqlExpressionTests.cs

@@ -46,6 +46,12 @@ public class WaybillBase : ObjectBase
         [DataAnnotations.Ignore]
         public bool BoolVirtProperty => false;
 
+        [DataAnnotations.Ignore]
+        public bool? NullableTrueBoolVirtProperty => true;
+
+        [DataAnnotations.Ignore]
+        public bool? NullableNullBoolVirtProperty => null;
+
         [DataAnnotations.Ignore]
         public Guid GuidVirtProperty => Guid.Parse("00000000-0000-0000-0000-000000000000");
 
@@ -112,6 +118,10 @@ protected override Object GetMemberExpression(MemberExpression m)
                     return null;
                 if (m.Member.Name == nameof(WaybillBase.BoolVirtProperty))
                     return false;
+                if (m.Member.Name == nameof(WaybillBase.NullableTrueBoolVirtProperty))
+                    return true;
+                if (m.Member.Name == nameof(WaybillBase.NullableNullBoolVirtProperty))
+                    return null;
                 if (m.Member.Name == nameof(WaybillBase.GuidVirtProperty))
                     return Guid.Parse("00000000-0000-0000-0000-000000000000");
                 if (m.Member.Name == nameof(WaybillBase.DateVirtProperty))
@@ -603,5 +613,181 @@ public void Can_Where_using_StringLengthVirtualProperty5()
             var target = Db.Select(q);
             Assert.AreEqual(3, target.Count);
         }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty6()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.BoolVirtProperty != null;//should be always true
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where null"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty7()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => null != x.BoolVirtProperty;//should be always true
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where null"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty8()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => null != x.BoolVirtProperty && x.Id > 0;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where null"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty9()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.BoolVirtProperty == null;//should be always false
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where not (null)"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty10()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => null == x.BoolVirtProperty;//should be always false
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where not (null)"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty11()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.NullableTrueBoolVirtProperty == null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where null"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty12()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.NullableTrueBoolVirtProperty != null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where not (null)"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty13()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.NullableNullBoolVirtProperty == null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty14()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.NullableNullBoolVirtProperty != null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty15()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.NullableNullBoolVirtProperty == true;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty16()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.BoolVirtProperty != false;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            Assert.That(q.ToSelectStatement().ToLower(), Does.Not.Contain("where null"));
+
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty17()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.VirtPropertyNull == null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty18()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.VirtPropertyNull != null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty19()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.VirtPropertyNull == "null";
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty20()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.VirtProperty == null;
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_StringLengthVirtualProperty21()
+        {
+            System.Linq.Expressions.Expression<Func<WaybillBase, bool>> filter = x => x.VirtProperty == "WaybillVirtPropertyValue";
+
+            var q = Db.From<WaybillBase>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
     }
 }