Example #1
0
        protected override SqlPack Having(BinaryExpression expression, SqlPack sqlPack)
        {
            if (HasBeginInOwnLogic(expression, sqlPack))
            {
                sqlPack += " (";
            }


            FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
            int signIndex = sqlPack.Length;

            FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
            int sqlLength = sqlPack.Length;

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

            if (HasEndInOwnLogic(expression, sqlPack))
            {
                sqlPack += ")";
            }
            return(sqlPack);
        }
Example #2
0
        protected override SqlPack Join(BinaryExpression expression, SqlPack sqlPack)
        {
            FluentExpressionSQLProvider.Join(expression.Left, sqlPack);
            int operatorIndex = sqlPack.Sql.Length;

            FluentExpressionSQLProvider.Join(expression.Right, sqlPack);
            int sqlLength = sqlPack.Sql.Length;

            if (sqlLength - operatorIndex == 5 && sqlPack.ToString().EndsWith("null"))
            {
                OperatorParser(expression.NodeType, operatorIndex, sqlPack, true);
            }
            else
            {
                OperatorParser(expression.NodeType, operatorIndex, sqlPack);
            }

            return(sqlPack);
        }
Example #3
0
        private void AppendSql(Expression exp, SqlPack sqlPack)
        {
            var expression = exp as BinaryExpression;

            FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
            int signIndex = sqlPack.Length;

            FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
            int sqlLength = sqlPack.Length;

            if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null", StringComparison.InvariantCultureIgnoreCase))
            {
                OperatorParser(expression.NodeType, signIndex, sqlPack, true);
            }
            else
            {
                OperatorParser(expression.NodeType, signIndex, sqlPack);
            }
        }
Example #4
0
        protected override SqlPack Where(BinaryExpression expression, SqlPack sqlPack)
        {
            int signIndex = 0, sqlLength = 0;

            if (expression.NodeType == ExpressionType.AndAlso)
            {
                // true && a.ID == 1 或者 a.ID == 1 && true
                Expression         left = expression.Left, right = expression.Right;
                ConstantExpression c = right as ConstantExpression;
                // DbExpression dbExp = null;
                //a.ID == 1 && true
                if (c != null)
                {
                    if ((bool)c.Value == true)
                    {
                        // (a.ID==1)==true
                        //dbExp = new DbEqualExpression(this.Visit(exp.Left), new DbConstantExpression(true));
                        //dbExp = this.Visit(Expression.Equal(exp.Left, UtilConstants.Constant_True));
                        FluentExpressionSQLProvider.Where(expression.Left, sqlPack);

                        signIndex = sqlPack.Length;

                        sqlPack  += " " + TrueLiteral;
                        sqlLength = sqlPack.Length;

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

                        return(sqlPack);
                    }
                    else
                    {
                        sqlPack += " " + FalseLiteral;
                        return(sqlPack);
                        //dbExp = DbEqualExpression.False;
                        // return dbExp;
                    }
                }

                c = left as ConstantExpression;
                // true && a.ID == 1
                if (c != null)
                {
                    if ((bool)c.Value == true)
                    {
                        // (a.ID==1)==true

                        sqlPack  += " " + TrueLiteral;
                        signIndex = sqlPack.Length;

                        FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
                        sqlLength = sqlPack.Length;


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

                        return(sqlPack);

                        //dbExp = this.Visit(Expression.Equal(exp.Right, UtilConstants.Constant_True));
                        //return dbExp;
                    }
                    else
                    {
                        // 直接 (1=0)

                        sqlPack += " " + FalseLiteral;
                        return(sqlPack);
                        //dbExp = DbEqualExpression.False;
                        // return dbExp;
                    }
                }
            }
            else if (expression.NodeType == ExpressionType.OrElse)
            {
                // true && a.ID == 1 或者 a.ID == 1 && true
                Expression         left = expression.Left, right = expression.Right;
                ConstantExpression c = right as ConstantExpression;
                //DbExpression dbExp = null;
                //a.ID == 1 || true
                if (c != null)
                {
                    if ((bool)c.Value == false)
                    {
                        // (a.ID==1)==true
                        FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
                        signIndex = sqlPack.Length;

                        sqlPack  += " " + FalseLiteral;
                        sqlLength = sqlPack.Length;

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

                        return(sqlPack);
                        //dbExp = this.Visit(Expression.Equal(exp.Left, UtilConstants.Constant_True));
                        //return dbExp;
                    }
                    else
                    {
                        sqlPack += " " + TrueLiteral;
                        return(sqlPack);

                        // dbExp = DbEqualExpression.True;
                        // return dbExp;
                    }
                }

                c = left as ConstantExpression;
                // true || a.ID == 1
                if (c != null)
                {
                    if ((bool)c.Value == false)
                    {
                        // (a.ID==1)==true
                        sqlPack  += " " + FalseLiteral;
                        signIndex = sqlPack.Length;

                        FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
                        sqlLength = sqlPack.Length;

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

                        return(sqlPack);

                        //dbExp = this.Visit(Expression.Equal(exp.Right, UtilConstants.Constant_True));
                        //return dbExp;
                    }
                    else
                    {
                        // 直接 (1=1)
                        sqlPack += " " + TrueLiteral;
                        return(sqlPack);
                        //dbExp = DbEqualExpression.True;
                        //return dbExp;
                    }
                }
            }



            if (HasBeginInOwnLogic(expression, sqlPack))
            {
                sqlPack += " (";
            }

            //sqlPack.WhereConditionIndex = sqlPack.WhereConditionIndex + 1;


            FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
            signIndex = sqlPack.Length;

            FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
            sqlLength = sqlPack.Length;

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

            if (HasEndInOwnLogic(expression, sqlPack))
            {
                sqlPack += ")";
            }
            return(sqlPack);
        }