Handle when selecting against an interface in a generic method

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1713,6 +1713,15 @@ protected virtual bool IsParameterOrConvertAccess(Expression e)
             return CheckExpressionForTypes(e, new[] { ExpressionType.Parameter, ExpressionType.Convert });
         }
 
+        /// <summary>
+        /// Check whether the expression is a constant expression to determine
+        /// whether we should use the expression value instead of Column Name 
+        /// </summary>
+        protected virtual bool IsConstantExpression(Expression e)
+        {
+            return CheckExpressionForTypes(e, new[] { ExpressionType.Constant });
+        }
+
         protected bool CheckExpressionForTypes(Expression e, ExpressionType[] types)
         {
             while (e != null)
@@ -1826,7 +1835,11 @@ protected virtual object VisitMemberAccess(MemberExpression m)
                 }
 
                 if (IsParameterOrConvertAccess(m))
-                    return GetMemberExpression(m);
+                {
+                    // We don't want to use the Column Name for constant expressions unless we're in a Sql. method call
+                    if (inSqlMethodCall || !IsConstantExpression(m))
+                        return GetMemberExpression(m);
+                }
             }
 
             return CachedExpressionCompiler.Evaluate(m);
@@ -2213,10 +2226,18 @@ protected virtual bool IsColumnAccess(MethodCallExpression m)
                    && IsJoinedTable(exp.Expression.Type);
         }
 
+        private bool inSqlMethodCall = false;
+
         protected virtual object VisitMethodCall(MethodCallExpression m)
         {
             if (m.Method.DeclaringType == typeof(Sql))
-                return VisitSqlMethodCall(m);
+            {
+                var hold = inSqlMethodCall;
+                inSqlMethodCall = true;
+                var ret = VisitSqlMethodCall(m);
+                inSqlMethodCall = hold;
+                return ret;
+            }
 
             if (IsStaticArrayMethod(m))
                 return VisitStaticArrayMethodCall(m);

tests/ServiceStack.OrmLite.Tests/Issues/SelectAliasIssue.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System;
+using System.Data;
+using System.Linq;
 using NUnit.Framework;
 using ServiceStack.DataAnnotations;
 using ServiceStack.Text;
@@ -15,6 +17,33 @@ public class AddressAudit
         public int AddressId { get; set; }
     }
 
+    public interface ILookup
+    {
+        Guid Id { get; set; }
+        string Name { get; }
+    }
+
+    public class TestLookup : ILookup
+    {
+        public Guid Id { get; set; }
+        public string Name { get; set; }
+    }
+
+    public static class TestLookupExtensions
+    {
+        public static T Lookup<T>(this IDbConnection db, T record) where T : ILookup, new()
+        {
+            var lkp = db.Single<T>(r => r.Name == record.Name);
+            if (lkp != null)
+                return lkp;
+
+            if (record.Id == Guid.Empty)
+                record.Id = Guid.NewGuid();
+            db.Insert(record);
+            return record;
+        }
+    }
+
     [TestFixtureOrmLite]
     public class SelectAliasIssue : OrmLiteProvidersTestBase
     {
@@ -40,5 +69,22 @@ public void Does_populate_table_with_Aliases_having_same_name_as_alternative_fie
                 row.PrintDump();
             }
         }
+        
+        [Test]
+        public void Select_against_interface_in_generic_method()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.CreateTable<TestLookup>();
+                
+                var newRecord = new TestLookup {Name = "new"};
+                
+                var lkp = db.Single<TestLookup>(r => r.Name == newRecord.Name);
+
+                
+                var lookup = db.Lookup(newRecord);
+                Assert.That(lookup.Id != Guid.Empty);
+            }
+        }
     }
 }