Add support for custom Visiting for virtual propertiis in custom SqlExpression

Author: OlegNadymov

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1363,7 +1363,19 @@ protected virtual object VisitBinary(BinaryExpression b)
                 }
                 else if (!(left is PartialSqlString) && !(right is PartialSqlString))
                 {
-                    var evaluatedValue = CachedExpressionCompiler.Evaluate(b);
+                    var visitedBinaryExp = b;
+
+                    if (IsParameterAccess(b.Left) || IsParameterAccess(b.Right))
+                    {
+                        var eLeft = !IsParameterAccess(b.Left) ? b.Left : Expression.Constant(left, b.Left.Type);
+                        var eRight = !IsParameterAccess(b.Right) ? b.Right : Expression.Constant(right, b.Right.Type);
+                        if (b.NodeType == ExpressionType.Coalesce)
+                            visitedBinaryExp = Expression.Coalesce(eLeft, eRight, b.Conversion);
+                        else
+                            visitedBinaryExp = Expression.MakeBinary(b.NodeType, eLeft, eRight, b.IsLiftedToNull, b.Method);
+                    }
+
+                    var evaluatedValue = CachedExpressionCompiler.Evaluate(visitedBinaryExp);
                     var result = VisitConstant(Expression.Constant(evaluatedValue));
                     return result;
                 }

tests/ServiceStack.OrmLite.Tests/CustomSqlExpressionTests.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Data;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using ServiceStack.OrmLite.Sqlite;
+
+
+namespace ServiceStack.OrmLite.Tests
+{
+    public class Waybill
+    {
+        public int Id { get; set; }
+
+        public int Number { get; set; }
+
+        public string Name { get; set; }
+
+        public string VirtProperty => "WaybillVirtPropertyValue";
+    }
+
+    public class CustomSqlServerDialectProvider : SqliteOrmLiteDialectProvider
+    {
+        public override SqlExpression<T> SqlExpression<T>()
+        {
+            return new CustomSqlExpression<T>(this);
+        }
+    }
+
+    public class CustomSqlExpression<T> : SqlExpression<T>
+    {
+
+        public CustomSqlExpression(IOrmLiteDialectProvider dialectProvider) : base(dialectProvider)
+        {
+        }
+
+        protected override Object GetMemberExpression(MemberExpression m)
+        {
+            if (m.Member.DeclaringType == typeof(Waybill) &&
+                m.Member.Name == nameof(Waybill.VirtProperty))
+            {
+                return "WaybillVirtPropertyValue";
+            }
+
+            return base.GetMemberExpression(m);
+        }
+    }
+
+    [TestFixture]
+    public class CustomSqlExpressionTests : OrmLiteTestBase
+    {
+        private IDbConnection Db;
+        
+        [OneTimeSetUp]
+        public void CustomInit()
+        {
+            ConnectionString = Config.SqliteMemoryDb;
+            DbFactory = new OrmLiteConnectionFactory(ConnectionString, new CustomSqlServerDialectProvider());
+        }
+
+        [SetUp]
+        public void Setup()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropTable<Waybill>();
+
+                db.CreateTable<Waybill>();
+                db.Insert(new Waybill {Id = 1, Number = 100, Name = "first"});
+                db.Insert(new Waybill {Id = 2, Number = 200, Name = "second"});
+                db.Insert(new Waybill {Id = 3, Number = 300, Name = "third"});
+            }
+            Db = OpenDbConnection();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Db.Dispose();
+        }
+
+        [Test]
+        public void Can_Where_using_constant_filter1()
+        {
+            System.Linq.Expressions.Expression<Func<Waybill, bool>> filter = x => x.VirtProperty == "WaybillVirtPropertyValue";
+            var q = Db.From<Waybill>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_constant_filter2()
+        {
+            System.Linq.Expressions.Expression<Func<Waybill, bool>> filter = x => x.VirtProperty == "Any";
+            var q = Db.From<Waybill>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_constant_filter3()
+        {
+            System.Linq.Expressions.Expression<Func<Waybill, bool>> filter = x => x.VirtProperty != "WaybillVirtPropertyValue";
+            var q = Db.From<Waybill>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(0, target.Count);
+        }
+
+        [Test]
+        public void Can_Where_using_constant_filter4()
+        {
+            System.Linq.Expressions.Expression<Func<Waybill, bool>> filter = x => x.VirtProperty != "Any";
+            var q = Db.From<Waybill>().Where(filter);
+            var target = Db.Select(q);
+            Assert.AreEqual(3, target.Count);
+        }
+    }
+}

tests/ServiceStack.OrmLite.Tests/ExpressionVisitorTests.cs

@@ -489,6 +489,19 @@ public void Can_Where_using_filter_with_Concat()
             Assert.That(target.Count, Is.EqualTo(1));
         }
 
+        [Test]
+        public void Can_Where_using_constant_filter()
+        {
+            object left = null;
+            var right = new PartialSqlString("null");
+
+            System.Linq.Expressions.Expression<Func<TestType, bool>> filter = x => left == right;
+            var q = Db.From<TestType>().Where(filter);//todo: here Where: null is NULL. May be need to change to 1=1 ?
+            var target = Db.Select(q);
+            Assert.That(target.Count, Is.EqualTo(4));
+
+        }
+
         private int MethodReturningInt(int val)
         {
             return val;

tests/ServiceStack.OrmLite.Tests/ServiceStack.OrmLite.Tests.csproj

@@ -136,6 +136,7 @@
     <Compile Include="Async\SqlExpressionTests.cs" />
     <Compile Include="Async\SqlServerProviderTestsAsync.cs" />
     <Compile Include="Async\UpdateAsyncTests.cs" />
+    <Compile Include="CustomSqlExpressionTests.cs" />
     <Compile Include="Expression\JoinAliasTests.cs" />
     <Compile Include="Expression\RestrictionTests.cs" />
     <Compile Include="Expression\SqlExpressionDeleteTests.cs" />