Added support for "Contains(x.Nullable.Value)" expressions to SqlExpression - useful when the database field is nullable, but the input array/list is not

Author: shift-evgeny

src/ServiceStack.OrmLite.SqlServer.Converters/SqlServerHierarchyIdTypeConverter.cs

@@ -27,14 +27,14 @@ public override DbType DbType
         public override void InitDbParam(IDbDataParameter p, Type fieldType)
         {
             var sqlParam = (SqlParameter)p;
-            sqlParam.IsNullable = (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>));
+            sqlParam.IsNullable = fieldType.IsNullableType();
             sqlParam.SqlDbType = SqlDbType.Udt;
             sqlParam.UdtTypeName = ColumnDefinition;
         }
 
         public override object FromDbValue(Type fieldType, object value)
         {
-            if (((SqlHierarchyId)value).IsNull && fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>))
+            if (((SqlHierarchyId)value).IsNull && fieldType.IsNullableType())
             {
                 return null;
             }

src/ServiceStack.OrmLite.SqlServer.Converters/SqlServerTypeConverter.cs

@@ -15,7 +15,7 @@ public override void InitDbParam(IDbDataParameter p, Type fieldType)
         {
             var sqlParam = (SqlParameter)p;
             sqlParam.SqlDbType = SqlDbType.Udt;
-            sqlParam.IsNullable = (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>));
+            sqlParam.IsNullable = fieldType.IsNullableType();
             sqlParam.UdtTypeName = ColumnDefinition;
         }
     }

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1335,11 +1335,13 @@ protected virtual void ConvertToPlaceholderAndParameter(ref object right)
 
         protected virtual object VisitMemberAccess(MemberExpression m)
         {
-            if (m.Expression != null && 
-                 (m.Expression.NodeType == ExpressionType.Parameter || 
-                  m.Expression.NodeType == ExpressionType.Convert))
+            if (m.Expression != null)
             {
-                return GetMemberExpression(m);
+                if (m.Member.DeclaringType.IsNullableType() && m.Member.Name == nameof(Nullable<bool>.Value))
+                    return Visit(m.Expression);
+
+                if (m.Expression.NodeType == ExpressionType.Parameter || m.Expression.NodeType == ExpressionType.Convert)
+                    return GetMemberExpression(m);
             }
 
             return CachedExpressionCompiler.Evaluate(m);

src/ServiceStack.OrmLite/OrmLiteConfigExtensions.cs

@@ -22,12 +22,6 @@ internal static class OrmLiteConfigExtensions
     {
         private static Dictionary<Type, ModelDefinition> typeModelDefinitionMap = new Dictionary<Type, ModelDefinition>();
 
-        private static bool IsNullableType(Type theType)
-        {
-            return (theType.IsGenericType
-                && theType.GetGenericTypeDefinition() == typeof(Nullable<>));
-        }
-
         internal static bool CheckForIdField(IEnumerable<PropertyInfo> objProperties)
         {
             // Not using Linq.Where() and manually iterating through objProperties just to avoid dependencies on System.Xml??
@@ -104,7 +98,7 @@ internal static ModelDefinition GetModelDefinition(this Type modelType)
                 var isRowVersion = propertyInfo.Name == ModelDefinition.RowVersionName
                     && propertyInfo.PropertyType == typeof(ulong);
 
-                var isNullableType = IsNullableType(propertyInfo.PropertyType);
+                var isNullableType = propertyInfo.PropertyType.IsNullableType();
 
                 var isNullable = (!propertyInfo.PropertyType.IsValueType
                                    && !propertyInfo.HasAttributeNamed(typeof(RequiredAttribute).Name))

tests/ServiceStack.OrmLite.Tests/ExpressionVisitorTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Data;
 using System.Linq;
 using NUnit.Framework;
@@ -16,10 +17,10 @@ public void Setup()
             using (var db = OpenDbConnection())
             {
                 db.DropAndCreateTable<TestType>();
-                db.Insert(new TestType { Id = 1, BoolCol = true, DateCol = new DateTime(2012, 1, 1), TextCol = "asdf", EnumCol = TestEnum.Val0 });
-                db.Insert(new TestType { Id = 2, BoolCol = true, DateCol = new DateTime(2012, 2, 1), TextCol = "asdf123", EnumCol = TestEnum.Val1 });
-                db.Insert(new TestType { Id = 3, BoolCol = false, DateCol = new DateTime(2012, 3, 1), TextCol = "qwer", EnumCol = TestEnum.Val2 });
-                db.Insert(new TestType { Id = 4, BoolCol = false, DateCol = new DateTime(2012, 4, 1), TextCol = "qwer123", EnumCol = TestEnum.Val3 });
+                db.Insert(new TestType { Id = 1, BoolCol = true, DateCol = new DateTime(2012, 1, 1), TextCol = "asdf", EnumCol = TestEnum.Val0, NullableIntCol = 10 });
+                db.Insert(new TestType { Id = 2, BoolCol = true, DateCol = new DateTime(2012, 2, 1), TextCol = "asdf123", EnumCol = TestEnum.Val1, NullableIntCol = null });
+                db.Insert(new TestType { Id = 3, BoolCol = false, DateCol = new DateTime(2012, 3, 1), TextCol = "qwer", EnumCol = TestEnum.Val2, NullableIntCol = 30 });
+                db.Insert(new TestType { Id = 4, BoolCol = false, DateCol = new DateTime(2012, 4, 1), TextCol = "qwer123", EnumCol = TestEnum.Val3, NullableIntCol = 40 });
             }
             Db = OpenDbConnection();
         }
@@ -145,6 +146,33 @@ public void Can_Select_using_IN_using_object_array()
             Assert.AreEqual(3, target.Count);
         }
 
+        [Test]
+        public void Can_Select_using_int_array_Contains()
+        {
+            var ids = new[] { 1, 2 };
+            var q = Db.From<TestType>().Where(x => ids.Contains(x.Id));
+            var target = Db.Select(q);
+            CollectionAssert.AreEquivalent(ids, target.Select(t => t.Id).ToArray());
+        }
+
+        [Test]
+        public void Can_Select_using_int_list_Contains()
+        {
+            var ids = new List<int> { 1, 2 };
+            var q = Db.From<TestType>().Where(x => ids.Contains(x.Id));
+            var target = Db.Select(q);
+            CollectionAssert.AreEquivalent(ids, target.Select(t => t.Id).ToArray());
+        }
+
+        [Test]
+        public void Can_Select_using_int_array_Contains_Value()
+        {
+            var ints = new[] { 10, 40 };
+            var q = Db.From<TestType>().Where(x => ints.Contains(x.NullableIntCol.Value)); // Doesn't compile without ".Value" here - "ints" is not nullable
+            var target = Db.Select(q);
+            CollectionAssert.AreEquivalent(new[] { 1, 4 }, target.Select(t => t.Id).ToArray());
+        }
+
         [Test]
         public void Can_Select_using_Startswith()
         {
@@ -240,5 +268,6 @@ public class TestType
         public DateTime DateCol { get; set; }
         public TestEnum EnumCol { get; set; }
         public TestType ComplexObjCol { get; set; }
+        public int? NullableIntCol { get; set; }
     }
 }