private void parseStatementList(TStatementList stmts)
 {
     for (int i = 0; i < stmts.size(); i++)
     {
         TCustomSqlStatement stmt = stmts.get(i);
         parseStatement(stmt);
     }
 }
        private void checkDDL(TGSqlParser sqlparser)
        {
            int ret = sqlparser.parse();

            if (ret == 0)
            {
                TStatementList stmts = sqlparser.sqlstatements;
                parseStatementList(stmts);
            }
        }
Exemple #3
0
        private void checkDDL(TGSqlParser sqlparser)
        {
            int ret = sqlparser.parse();

            if (ret == 0)
            {
                TStatementList stmts = sqlparser.sqlstatements;
                for (int i = 0; i < stmts.size(); i++)
                {
                    TCustomSqlStatement stmt = stmts.get(i);
                    parseStatement(stmt);
                }
            }
        }
        public virtual bool exprVisit(TParseTreeNode pnode, bool pIsLeafNode)
        {
            TExpression expression = (TExpression)pnode;

            if (expression.ExpressionType == EExpressionType.parenthesis_t)
            {
                expression = expression.LeftOperand;
            }
            if (is_compare_condition(expression.ExpressionType))
            {
                TExpression leftExpr  = (TExpression)expression.LeftOperand;
                TExpression rightExpr = (TExpression)expression.RightOperand;

                TExpression[] leftExprs  = new TExpression[] { leftExpr };
                TExpression[] rightExprs = new TExpression[] { rightExpr };
                if (leftExpr != null && !checkCondition(leftExprs))
                {
                    removeExpression(expression);
                }

                expression.LeftOperand = leftExprs[0];

                if (rightExpr != null && !checkCondition(rightExprs))
                {
                    removeExpression(expression);
                }

                expression.RightOperand = rightExprs[0];

                if ((expression.LeftOperand != null && string.ReferenceEquals(toExprString(expression.LeftOperand.ToScript()), null)) || (expression.RightOperand != null && string.ReferenceEquals(toExprString(expression.RightOperand.ToScript()), null)))
                {
                    removeExpression(expression);
                }
            }
            if (expression.ExpressionType == EExpressionType.between_t)
            {
                TExpression[] exprs = new TExpression[] { expression };
                if (!checkCondition(exprs))
                {
                    removeExpression(expression);
                }
                if (expression.OperatorToken != null && string.ReferenceEquals(toExprString(expression.OperatorToken.ToString()), null))
                {
                    removeExpression(expression);
                }
            }
            if (expression.ExpressionType == EExpressionType.pattern_matching_t)
            {
                TExpression[] exprs = new TExpression[] { expression };
                if (!checkCondition(exprs))
                {
                    removeExpression(expression);
                }
                if (expression.OperatorToken != null && string.ReferenceEquals(toExprString(expression.OperatorToken.ToString()), null))
                {
                    removeExpression(expression);
                }
            }
            if (expression.ExpressionType == EExpressionType.in_t)
            {
                TExpression   left      = expression.LeftOperand;
                TExpression[] leftExprs = new TExpression[] { left };
                if (!checkCondition(leftExprs))
                {
                    removeExpression(expression);
                    return(true);
                }
                expression.LeftOperand = leftExprs[0];

                TExpression   right      = expression.RightOperand;
                TExpression[] rightExprs = new TExpression[] { right };
                if (right.SubQuery != null)
                {
                    right.SubQuery.String = removevars.remove(right.SubQuery);
                }
                else if (!checkCondition(rightExprs))
                {
                    removeExpression(expression);
                }
                expression.RightOperand = rightExprs[0];

                if (expression.OperatorToken != null && string.ReferenceEquals(toExprString(expression.OperatorToken.ToString()), null))
                {
                    removeExpression(expression);
                }
            }
            if (expression.FunctionCall != null)
            {
                TFunctionCall func = (TFunctionCall)expression.FunctionCall;
                checkFunctionCall(func);
            }
            if (expression.SubQuery is TCustomSqlStatement)
            {
                expression.SubQuery.String = removevars.remove(expression.SubQuery);
            }
            if (expression.CaseExpression != null)
            {
                TCaseExpression expr          = expression.CaseExpression;
                TExpression     conditionExpr = expr.Input_expr;
                if (conditionExpr != null)
                {
                    if (conditionExpr.SubQuery != null)
                    {
                        conditionExpr.SubQuery.String = removevars.remove(conditionExpr.SubQuery);
                    }
                }
                TExpression defaultExpr = expr.Else_expr;
                if (defaultExpr != null)
                {
                    if (defaultExpr.SubQuery != null)
                    {
                        defaultExpr.SubQuery.String = removevars.remove(defaultExpr.SubQuery);
                    }
                }
                TStatementList defaultStatList = expr.Else_statement_list;
                if (defaultStatList != null && defaultStatList.size() > 0)
                {
                    for (int i = 0; i < defaultStatList.size(); i++)
                    {
                        TCustomSqlStatement stmt = defaultStatList.get(i);
                        stmt.String = removevars.remove(stmt);
                    }
                }

                TWhenClauseItemList list = expr.WhenClauseItemList;
                if (list != null && list.size() > 0)
                {
                    for (int i = 0; i < list.size(); i++)
                    {
                        TWhenClauseItem item = list.getWhenClauseItem(i);
                        if (item.Comparison_expr != null)
                        {
                            if (item.Comparison_expr.SubQuery != null)
                            {
                                item.Comparison_expr.SubQuery.String = removevars.remove(item.Comparison_expr.SubQuery);
                            }
                        }
                        if (item.Return_expr != null)
                        {
                            if (item.Return_expr.SubQuery != null)
                            {
                                item.Return_expr.SubQuery.String = removevars.remove(item.Return_expr.SubQuery);
                            }
                        }
                        TStatementList statList = expr.Else_statement_list;
                        if (statList != null && statList.size() > 0)
                        {
                            for (int j = 0; j < statList.size(); j++)
                            {
                                TCustomSqlStatement stmt = statList.get(j);
                                stmt.String = removevars.remove(statList.get(j));
                            }
                        }
                    }
                }

                if (expression.OperatorToken != null && string.ReferenceEquals(toExprString(expression.OperatorToken.ToString()), null))
                {
                    removeExpression(expression);
                }
            }

            if (expression.LeftOperand == null)
            {
                TExpression[] exprs = new TExpression[] { expression };
                if (!checkCondition(exprs))
                {
                    removeExpression(expression);
                }
            }
            return(true);
        }