Merge pull request #521 from OlegNadymov/master

Extracted method for checking Expression for the parameter.

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -41,7 +41,7 @@ public abstract partial class SqlExpression<T> : ISqlExpression, IHasUntypedSqlE
         public bool PrefixFieldWithTableName { get; set; }
         public bool WhereStatementWithoutWhereString { get; set; }
         public IOrmLiteDialectProvider DialectProvider { get; set; }
-        public List<IDbDataParameter> Params { get; set; } 
+        public List<IDbDataParameter> Params { get; set; }
 
         protected string Sep
         {
@@ -107,7 +107,7 @@ public virtual SqlExpression<T> Select(string selectExpression)
         {
             if (selectExpression != null)
                 selectExpression.SqlVerifyFragment();
-    
+
             return UnsafeSelect(selectExpression);
         }
 
@@ -590,7 +590,7 @@ private SqlExpression<T> OrderByFields(string orderBySuffix, string[] fieldNames
             foreach (var fieldName in fieldNames)
             {
                 var reverse = fieldName.StartsWith("-");
-                var useSuffix = reverse 
+                var useSuffix = reverse
                     ? (orderBySuffix == OrderBySuffix.Asc ? OrderBySuffix.Desc : OrderBySuffix.Asc)
                     : orderBySuffix;
                 var useName = reverse ? fieldName.Substring(1) : fieldName;
@@ -980,7 +980,7 @@ public virtual void PrepareUpdateStatement(IDbCommand dbCmd, T item, bool exclud
             {
                 if (fieldDef.ShouldSkipUpdate()) continue;
                 if (fieldDef.IsRowVersion) continue;
-                if (UpdateFields.Count > 0 
+                if (UpdateFields.Count > 0
                     && !UpdateFields.Contains(fieldDef.Name)) continue; // added
 
                 var value = fieldDef.GetValue(item);
@@ -1238,17 +1238,13 @@ protected virtual object VisitBinary(BinaryExpression b)
             var operand = BindOperant(b.NodeType);   //sep= " " ??
             if (operand == "AND" || operand == "OR")
             {
-                var m = b.Left as MemberExpression;
-                if (m != null && m.Expression != null
-                    && m.Expression.NodeType == ExpressionType.Parameter)
-                    left = new PartialSqlString(string.Format("{0}={1}", VisitMemberAccess(m), GetQuotedTrueValue()));
+                if (IsNeedCompareToTrue(b.Left))
+                    left = new PartialSqlString(string.Format("{0}={1}", VisitMemberAccess((MemberExpression) b.Left), GetQuotedTrueValue()));
                 else
                     left = Visit(b.Left);
 
-                m = b.Right as MemberExpression;
-                if (m != null && m.Expression != null
-                    && m.Expression.NodeType == ExpressionType.Parameter)
-                    right = new PartialSqlString(string.Format("{0}={1}", VisitMemberAccess(m), GetQuotedTrueValue()));
+                if (IsNeedCompareToTrue(b.Right))
+                    right = new PartialSqlString(string.Format("{0}={1}", VisitMemberAccess((MemberExpression) b.Right), GetQuotedTrueValue()));
                 else
                     right = Visit(b.Right);
 
@@ -1355,6 +1351,90 @@ protected virtual object VisitBinary(BinaryExpression b)
             }
         }
 
+        /// <summary>
+        /// Determines whether the expression is the parameter inside MemberExpression which should be compared with TrueExpression.
+        /// </summary>
+        /// <param name="e">The specified expression.</param>
+        /// <returns>Returns true if the specified expression is the parameter inside MemberExpression which should be compared with TrueExpression;
+        /// otherwise, false.</returns>
+        protected virtual bool IsNeedCompareToTrue(Expression e)
+        {
+            if (!(e is MemberExpression)) return false;
+
+            var m = (MemberExpression)e;
+
+            if (m.Member.DeclaringType.IsNullableType() &&
+                m.Member.Name == "HasValue") //nameof(Nullable<bool>.HasValue))
+                return false;
+
+            return IsParameterAccess(m);
+        }
+
+        /// <summary>
+        /// Determines whether the expression is the parameter.
+        /// </summary>
+        /// <param name="e">The specified expression.</param>
+        /// <returns>Returns true if the specified expression is parameter;
+        /// otherwise, false.</returns>
+        protected virtual bool IsParameterAccess(Expression e)
+        {
+            return CheckExpressionForTypes(e, new[] { ExpressionType.Parameter });
+        }
+
+        /// <summary>
+        /// Determines whether the expression is the parameter or convert.
+        /// </summary>
+        /// <param name="e">The specified expression.</param>
+        /// <returns>Returns true if the specified expression is parameter or convert;
+        /// otherwise, false.</returns>
+        protected virtual bool IsParameterOrConvertAccess(Expression e)
+        {
+            return CheckExpressionForTypes(e, new[] { ExpressionType.Parameter, ExpressionType.Convert });
+        }
+
+        protected bool CheckExpressionForTypes(Expression e, ExpressionType[] types)
+        {
+            while (e != null)
+            {
+                if (types.Contains(e.NodeType))
+                {
+                    var isSubExprAccess = e is UnaryExpression &&
+                                          ((UnaryExpression)e).Operand is IndexExpression;
+
+                    if (!isSubExprAccess)
+                        return true;
+                }
+
+                if (e is BinaryExpression)
+                {
+                    if (CheckExpressionForTypes(((BinaryExpression)e).Left, types))
+                        return true;
+
+                    if (CheckExpressionForTypes(((BinaryExpression)e).Right, types))
+                        return true;
+                }
+
+                if (e is MethodCallExpression)
+                {
+                    for (int i = 0; i < ((MethodCallExpression)e).Arguments.Count; i++)
+                    {
+                        if (CheckExpressionForTypes(((MethodCallExpression)e).Arguments[0], types))
+                            return true;
+                    }
+                }
+
+                if (e is UnaryExpression)
+                {
+                    if (CheckExpressionForTypes(((UnaryExpression)e).Operand, types))
+                        return true;
+                }
+
+                e = e is MemberExpression ? ((MemberExpression)e).Expression : null;
+            }
+
+            return false;
+        }
+
         private static void Swap(ref object left, ref object right)
         {
             var temp = right;
@@ -1403,19 +1483,14 @@ protected virtual object VisitMemberAccess(MemberExpression m)
                     throw new ArgumentException(string.Format("Expression '{0}' accesses unsupported property '{1}' of Nullable<T>", m, m.Member));
                 }
 
-                if (m.Expression.NodeType == ExpressionType.Parameter || m.Expression.NodeType == ExpressionType.Convert)
-                {
-                    var isSubExprAccess = m.Expression is UnaryExpression && 
-                        ((UnaryExpression)m.Expression).Operand is IndexExpression;
-                    if (!isSubExprAccess)
-                        return GetMemberExpression(m);
-                }
+                if (IsParameterOrConvertAccess(m))
+                    return GetMemberExpression(m);
             }
 
             return CachedExpressionCompiler.Evaluate(m);
         }
 
-        private object GetMemberExpression(MemberExpression m)
+        protected virtual object GetMemberExpression(MemberExpression m)
         {
             var propertyInfo = m.Member as PropertyInfo;
 
@@ -1482,8 +1557,8 @@ private object SetAnonTypePropertyNamesForSelectExpression(object expr, Expressi
             // to allow the caller to distinguish properties with the same names from different tables
 
             var paramExpr = arg as ParameterExpression;
-            var selectList = paramExpr != null && paramExpr.Name != member.Name 
-                ? expr as SelectList 
+            var selectList = paramExpr != null && paramExpr.Name != member.Name
+                ? expr as SelectList
                 : null;
             if (selectList != null)
             {
@@ -1567,7 +1642,13 @@ protected virtual object VisitUnary(UnaryExpression u)
                     return GetNotValue(o);
                 case ExpressionType.Convert:
                     if (u.Method != null)
+                    {
+                        var e = u.Operand;
+                        if (IsParameterAccess(e))
+                            return Visit(e);
+
                         return CachedExpressionCompiler.Evaluate(u);
+                    }
                     break;
             }
             return Visit(u.Operand);
@@ -1587,7 +1668,7 @@ protected virtual object VisitIndexExpression(IndexExpression e)
             var list = oCollection as List<object>;
             if (list != null)
                 return list[index];
-            
+
             throw new NotImplementedException("Unknown Expression: " + e);
         }
 
@@ -1606,12 +1687,10 @@ private bool IsColumnAccess(MethodCallExpression m)
         {
             if (m.Object != null && m.Object as MethodCallExpression != null)
                 return IsColumnAccess(m.Object as MethodCallExpression);
-            
+
             var exp = m.Object as MemberExpression;
-            return exp != null
-                && exp.Expression != null
-                && IsJoinedTable(exp.Expression.Type)
-                && exp.Expression.NodeType == ExpressionType.Parameter;
+            return IsParameterAccess(exp)
+                   && IsJoinedTable(exp.Expression.Type);
         }
 
         protected virtual object VisitMethodCall(MethodCallExpression m)
@@ -1732,11 +1811,11 @@ protected virtual string GetQuotedColumnName(ModelDefinition tableDef, string me
             if (useFieldName)
             {
                 var fd = tableDef.FieldDefinitions.FirstOrDefault(x => x.Name == memberName);
-                var fieldName = fd != null 
-                    ? fd.FieldName 
+                var fieldName = fd != null
+                    ? fd.FieldName
                     : memberName;
 
-                return PrefixFieldWithTableName 
+                return PrefixFieldWithTableName
                     ? DialectProvider.GetQuotedColumnName(tableDef, fieldName)
                     : DialectProvider.GetQuotedColumnName(fieldName);
             }
@@ -1941,7 +2020,7 @@ protected string ConvertInExpressionToSql(MethodCallExpression m, object quotedC
                 string sqlIn = CreateInParamSql(inArgs);
                 return string.Format("{0} {1} ({2})", quotedColName, m.Method.Name, sqlIn);
             }
-            
+
             var exprArg = argValue as ISqlExpression;
             if (exprArg != null)
             {