예제 #1
0
        protected override SqlGenerate Where(LambdaExpression expression, SqlGenerate sqlGenerate)
        {
            if (expression.Body.NodeType == ExpressionType.MemberAccess)
            {
                var memberExpression = expression.Body as MemberExpression;
                if (memberExpression.Expression == null)
                {
                    return(sqlGenerate);
                }

                //添加属性
                SqlExpressionProvider.Where(memberExpression, sqlGenerate);

                if (memberExpression.Expression.Type.IsNullableType())
                {
                    return(sqlGenerate);
                }

                sqlGenerate += " = 1";
                return(sqlGenerate);
            }

            SqlExpressionProvider.Where(expression.Body, sqlGenerate);
            return(sqlGenerate);
        }
예제 #2
0
        protected override SqlGenerate Where(MemberExpression expression, SqlGenerate sqlGenerate)
        {
            if (expression.Expression != null)
            {
                if (expression.Member.DeclaringType.IsNullableType())
                {
                    if (expression.Member.Name == "Value") //Can't use C# 6 yet: nameof(Nullable<bool>.Value)
                    {
                        SqlExpressionProvider.Where(expression.Expression, sqlGenerate);
                        return(sqlGenerate);
                    }
                    if (expression.Member.Name == "HasValue")
                    {
                        var doesNotEqualNull = Expression.MakeBinary(ExpressionType.NotEqual, expression.Expression, Expression.Constant(null));
                        SqlExpressionProvider.Where(doesNotEqualNull, sqlGenerate);
                        return(sqlGenerate);
                    }
                    throw new ArgumentException($"Expression '{expression}' accesses unsupported property '{expression.Member}' of Nullable<T>");
                }

                if (expression.IsParameterOrConvertAccess())
                {
                    sqlGenerate += $" {expression.Member.Name.ParamSql(sqlGenerate)}";
                    return(sqlGenerate);
                }
            }

            var val = SqlExpressionCompiler.Evaluate(expression);

            sqlGenerate.AddDbParameter(val);
            return(sqlGenerate);
        }
예제 #3
0
        protected override SqlGenerate Where(BinaryExpression expression, SqlGenerate sqlGenerate)
        {
            int leftBracketIndex = -1, rightBracketIndex = -1, signIndex = -1, sqlLength = -1;

            leftBracketIndex = sqlGenerate.Length;

            #region 内部内容
            if (expression.NodeType == ExpressionType.AndAlso || expression.NodeType == ExpressionType.OrElse)
            {
                if (expression.Left.IsBooleanComparison())
                {
                    SqlExpressionProvider.Where(expression.Left, sqlGenerate);
                    sqlGenerate += $" = 1";
                }
                else
                {
                    SqlExpressionProvider.Where(expression.Left, sqlGenerate);
                }
                signIndex = sqlGenerate.Length;


                if (expression.Right.IsBooleanComparison())
                {
                    SqlExpressionProvider.Where(expression.Right, sqlGenerate);
                    sqlGenerate += $" = 1";
                }
                else
                {
                    SqlExpressionProvider.Where(expression.Right, sqlGenerate);
                }
                sqlLength = sqlGenerate.Length;
            }
            else
            {
                SqlExpressionProvider.Where(expression.Left, sqlGenerate);
                signIndex = sqlGenerate.Length;

                SqlExpressionProvider.Where(expression.Right, sqlGenerate);
                sqlLength = sqlGenerate.Length;
            }

            if (sqlLength - signIndex == 5 && sqlGenerate.ToString().EndsWith("null"))
            {
                OperatorParser(expression.NodeType, signIndex, sqlGenerate, true);
            }
            else
            {
                OperatorParser(expression.NodeType, signIndex, sqlGenerate);
            }
            #endregion

            if (expression.NodeType == ExpressionType.OrElse || expression.NodeType == ExpressionType.AndAlso)
            {
                sqlGenerate.Sql.Insert(leftBracketIndex, " ( ");
                rightBracketIndex = sqlGenerate.Length;
                sqlGenerate.Sql.Insert(rightBracketIndex, " ) ");
            }

            return(sqlGenerate);
        }
        private static void StartsWith(MethodCallExpression expression, SqlGenerate sqlGenerate)
        {
            SqlExpressionProvider.Where(expression.Object, sqlGenerate);
            SqlExpressionProvider.Where(expression.Arguments[0], sqlGenerate);
            sqlGenerate += " like ";

            var val = SqlExpressionCompiler.Evaluate(expression.Arguments[0]);

            sqlGenerate.AddDbParameter($"{val}%");
        }
예제 #5
0
        /// <summary>
        /// Where条件
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public SqlExpressionCore <T> Where(Expression <Func <T, bool> > expression)
        {
            if (expression == null)
            {
                return(this);
            }

            sqlGenerate += $"{Environment.NewLine}where";
            SqlExpressionProvider.Where(expression, sqlGenerate);
            return(this);
        }
예제 #6
0
        protected override SqlGenerate Where(UnaryExpression expression, SqlGenerate sqlGenerate)
        {
            SqlExpressionProvider.Where(expression.Operand, sqlGenerate);
            switch (expression.NodeType)
            {
            case ExpressionType.Not:
                sqlGenerate += " = 0";
                break;
            }

            return(sqlGenerate);
        }
        internal static void DoStaticArrayMethodCall(MethodCallExpression expression, SqlGenerate sqlGenerate)
        {
            SqlExpressionProvider.Where(expression.Arguments[expression.Arguments.Count - 1], sqlGenerate);
            sqlGenerate += " in ";

            var memberExpr = expression.Arguments[0];

            if (memberExpr.NodeType == ExpressionType.MemberAccess)
            {
                memberExpr = expression.Arguments[0] as MemberExpression;
            }

            SqlExpressionProvider.In(memberExpr, sqlGenerate);
        }
        private static void Contains(MethodCallExpression expression, SqlGenerate sqlGenerate)
        {
            if (IsStaticArrayMethod(expression))
            {
                DoStaticArrayMethodCall(expression, sqlGenerate);
                return;
            }
            if (IsEnumerableMethod(expression))
            {
                DoEnumerableMethodCall(expression, sqlGenerate);
                return;
            }

            SqlExpressionProvider.Where(expression.Object, sqlGenerate);
            sqlGenerate += " like ";
            var val = SqlExpressionCompiler.Evaluate(expression.Arguments[0]);

            sqlGenerate.AddDbParameter($"%{val}%");
        }
 private static void Equals(MethodCallExpression expression, SqlGenerate sqlGenerate)
 {
     SqlExpressionProvider.Where(expression.Object, sqlGenerate);
     sqlGenerate += " = ";
     SqlExpressionProvider.Where(expression.Arguments[0], sqlGenerate);
 }
예제 #10
0
 private static new void In(MethodCallExpression expression, SqlGenerate sqlGenerate)
 {
     SqlExpressionProvider.Where(expression.Arguments[0], sqlGenerate);
     sqlGenerate += " in ";
     SqlExpressionProvider.In(expression.Arguments[1], sqlGenerate);
 }
예제 #11
0
 internal static void DoEnumerableMethodCall(MethodCallExpression expression, SqlGenerate sqlGenerate)
 {
     SqlExpressionProvider.Where(expression.Arguments[0], sqlGenerate);
     sqlGenerate += " in ";
     SqlExpressionProvider.In(expression.Object, sqlGenerate);
 }