예제 #1
0
 protected override Expression VisitConstant(ConstantExpression node)
 {
     if (Orm.IsColumnTypeSupported(node.Type))
     {
         return(new HostParameterExpression(node.Type, node.Value));
     }
     return(base.VisitConstant(node));
 }
예제 #2
0
            /// <summary>
            /// Determines whether the given expression can be represented as a column in a select expressionss
            /// </summary>
            /// <param name="expression"></param>
            /// <returns></returns>
            private bool CanBeColumn(Expression expression)
            {
                switch (expression.NodeType)
                {
                case ExpressionType.Add:
                case ExpressionType.AddChecked:
                case ExpressionType.Subtract:
                case ExpressionType.SubtractChecked:
                case ExpressionType.Multiply:
                case ExpressionType.MultiplyChecked:
                case ExpressionType.Divide:
                case ExpressionType.Modulo:
                case ExpressionType.And:
                case ExpressionType.AndAlso:
                case ExpressionType.Or:
                case ExpressionType.OrElse:
                case ExpressionType.ExclusiveOr:
                case ExpressionType.OnesComplement:
                case ExpressionType.Not:
                case ExpressionType.Negate:
                case ExpressionType.NegateChecked:
                case ExpressionType.UnaryPlus:
                case ExpressionType.RightShift:
                case ExpressionType.LeftShift:
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                case ExpressionType.GreaterThan:
                case ExpressionType.GreaterThanOrEqual:
                case ExpressionType.LessThan:
                case ExpressionType.LessThanOrEqual:
                case ExpressionType.Coalesce:
                    return(true);

                case ExpressionType.Constant:
                    return(Orm.IsColumnTypeSupported(expression.Type));

                case ExpressionType.Convert:
                case ExpressionType.ConvertChecked:
                    return(true);

                case ExpressionType.Conditional:
                    return(true);

                case ExpressionType.Call:
                    Type declaringType = ((MethodCallExpression)expression).Method.DeclaringType;
                    if (declaringType == typeof(DateTime) || declaringType == typeof(DateTimeOffset) ||
                        declaringType == typeof(TimeSpan) || declaringType == typeof(string) ||
                        declaringType == typeof(decimal) || declaringType == typeof(Math))
                    {
                        return(true);
                    }
                    goto default;

                case ExpressionType.MemberAccess:
                    Type mDeclaringType = ((MemberExpression)expression).Member.DeclaringType;
                    if (mDeclaringType == typeof(DateTime) || mDeclaringType == typeof(DateTimeOffset) ||
                        mDeclaringType == typeof(TimeSpan) || mDeclaringType == typeof(string))
                    {
                        return(true);
                    }
                    goto default;

                default:
                    return(MustBeColumn(expression));
                }
            }