Examples with SQLIdentifierExpr com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr used on opensource projects

Example 11 with SQLIdentifierExpr

use of com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr in project druid by alibaba.

the class MySqlCreateTableParser method partitionClauseRest.

protected void partitionClauseRest(SQLPartitionBy clause) {
    if (identifierEquals("PARTITIONS")) {
        lexer.nextToken();
        SQLIntegerExpr countExpr = this.exprParser.integerExpr();
        clause.setPartitionsCount(countExpr);
    }
    if (lexer.token() == Token.PARTITION) {
        lexer.nextToken();
        if (identifierEquals("NUM")) {
            lexer.nextToken();
        }
        clause.setPartitionsCount(this.exprParser.expr());
        clause.putAttribute("ads.partition", Boolean.TRUE);
    }
    if (identifierEquals("SUBPARTITION")) {
        lexer.nextToken();
        accept(Token.BY);
        SQLSubPartitionBy subPartitionByClause = null;
        boolean linear = false;
        if (identifierEquals("LINEAR")) {
            lexer.nextToken();
            linear = true;
        }
        if (lexer.token() == Token.KEY) {
            MySqlSubPartitionByKey subPartitionKey = new MySqlSubPartitionByKey();
            lexer.nextToken();
            if (linear) {
                clause.setLinear(true);
            }
            accept(Token.LPAREN);
            for (; ; ) {
                subPartitionKey.addColumn(this.exprParser.name());
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                }
                break;
            }
            accept(Token.RPAREN);
            subPartitionByClause = subPartitionKey;
        } else if (identifierEquals("HASH")) {
            lexer.nextToken();
            SQLSubPartitionByHash subPartitionHash = new SQLSubPartitionByHash();
            if (linear) {
                clause.setLinear(true);
            }
            if (lexer.token() == Token.KEY) {
                lexer.nextToken();
                subPartitionHash.setKey(true);
            }
            accept(Token.LPAREN);
            subPartitionHash.setExpr(this.exprParser.expr());
            accept(Token.RPAREN);
            subPartitionByClause = subPartitionHash;
        } else if (identifierEquals("LIST")) {
            lexer.nextToken();
            MySqlSubPartitionByList subPartitionList = new MySqlSubPartitionByList();
            if (lexer.token() == Token.LPAREN) {
                lexer.nextToken();
                SQLExpr expr = this.exprParser.expr();
                if (expr instanceof SQLIdentifierExpr && (identifierEquals("bigint") || identifierEquals("long"))) {
                    String dataType = lexer.stringVal();
                    lexer.nextToken();
                    SQLColumnDefinition column = this.exprParser.createColumnDefinition();
                    column.setName((SQLIdentifierExpr) expr);
                    column.setDataType(new SQLDataTypeImpl(dataType));
                    subPartitionList.addColumn(column);
                    subPartitionList.putAttribute("ads.subPartitionList", Boolean.TRUE);
                } else {
                    subPartitionList.setExpr(expr);
                }
                accept(Token.RPAREN);
            } else {
                acceptIdentifier("COLUMNS");
                accept(Token.LPAREN);
                for (; ; ) {
                    subPartitionList.addColumn(this.exprParser.parseColumn());
                    if (lexer.token() == Token.COMMA) {
                        lexer.nextToken();
                        continue;
                    }
                    break;
                }
                accept(Token.RPAREN);
            }
            subPartitionByClause = subPartitionList;
        }
        if (identifierEquals("SUBPARTITION")) {
            lexer.nextToken();
            acceptIdentifier("OPTIONS");
            accept(Token.LPAREN);
            SQLAssignItem option = this.exprParser.parseAssignItem();
            accept(Token.RPAREN);
            option.setParent(subPartitionByClause);
            subPartitionByClause.getOptions().add(option);
        }
        if (identifierEquals("SUBPARTITIONS")) {
            lexer.nextToken();
            Number intValue = lexer.integerValue();
            SQLNumberExpr numExpr = new SQLNumberExpr(intValue);
            subPartitionByClause.setSubPartitionsCount(numExpr);
            lexer.nextToken();
        }
        if (subPartitionByClause != null) {
            subPartitionByClause.setLinear(linear);
            clause.setSubPartitionBy(subPartitionByClause);
        }
    }
}

Example 12 with SQLIdentifierExpr

use of com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr in project druid by alibaba.

the class MySqlExprParser method primaryRest.

public final SQLExpr primaryRest(SQLExpr expr) {
    if (expr == null) {
        throw new IllegalArgumentException("expr");
    }
    if (lexer.token() == Token.LITERAL_CHARS) {
        if (expr instanceof SQLIdentifierExpr) {
            SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
            String ident = identExpr.getName();
            if (ident.equalsIgnoreCase("x")) {
                String charValue = lexer.stringVal();
                lexer.nextToken();
                expr = new SQLHexExpr(charValue);
                return primaryRest(expr);
            } else if (ident.equalsIgnoreCase("b")) {
                String charValue = lexer.stringVal();
                lexer.nextToken();
                expr = new SQLBinaryExpr(charValue);
                return primaryRest(expr);
            } else if (ident.startsWith("_")) {
                String charValue = lexer.stringVal();
                lexer.nextToken();
                MySqlCharExpr mysqlCharExpr = new MySqlCharExpr(charValue);
                mysqlCharExpr.setCharset(identExpr.getName());
                if (identifierEquals("COLLATE")) {
                    lexer.nextToken();
                    String collate = lexer.stringVal();
                    mysqlCharExpr.setCollate(collate);
                    accept(Token.IDENTIFIER);
                }
                expr = mysqlCharExpr;
                return primaryRest(expr);
            }
        } else if (expr instanceof SQLCharExpr) {
            SQLMethodInvokeExpr concat = new SQLMethodInvokeExpr("CONCAT");
            concat.addParameter(expr);
            do {
                String chars = lexer.stringVal();
                concat.addParameter(new SQLCharExpr(chars));
                lexer.nextToken();
            } while (lexer.token() == Token.LITERAL_CHARS || lexer.token() == Token.LITERAL_ALIAS);
            expr = concat;
        }
    } else if (lexer.token() == Token.IDENTIFIER) {
        if (expr instanceof SQLHexExpr) {
            if ("USING".equalsIgnoreCase(lexer.stringVal())) {
                lexer.nextToken();
                if (lexer.token() != Token.IDENTIFIER) {
                    throw new ParserException("syntax error, illegal hex");
                }
                String charSet = lexer.stringVal();
                lexer.nextToken();
                expr.getAttributes().put("USING", charSet);
                return primaryRest(expr);
            }
        } else if ("COLLATE".equalsIgnoreCase(lexer.stringVal())) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            if (lexer.token() != Token.IDENTIFIER) {
                throw new ParserException("syntax error");
            }
            String collate = lexer.stringVal();
            lexer.nextToken();
            SQLBinaryOpExpr binaryExpr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.COLLATE, new SQLIdentifierExpr(collate), JdbcConstants.MYSQL);
            expr = binaryExpr;
            return primaryRest(expr);
        } else if (expr instanceof SQLVariantRefExpr) {
            if ("COLLATE".equalsIgnoreCase(lexer.stringVal())) {
                lexer.nextToken();
                if (lexer.token() != Token.IDENTIFIER) {
                    throw new ParserException("syntax error");
                }
                String collate = lexer.stringVal();
                lexer.nextToken();
                expr.putAttribute("COLLATE", collate);
                return primaryRest(expr);
            }
        } else if (expr instanceof SQLIntegerExpr) {
            SQLIntegerExpr intExpr = (SQLIntegerExpr) expr;
            String binaryString = lexer.stringVal();
            if (intExpr.getNumber().intValue() == 0 && binaryString.startsWith("b")) {
                lexer.nextToken();
                expr = new SQLBinaryExpr(binaryString.substring(1));
                return primaryRest(expr);
            }
        }
    }
    if (lexer.token() == Token.LPAREN && expr instanceof SQLIdentifierExpr) {
        SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
        String ident = identExpr.getName();
        if ("EXTRACT".equalsIgnoreCase(ident)) {
            lexer.nextToken();
            if (lexer.token() != Token.IDENTIFIER) {
                throw new ParserException("syntax error");
            }
            String unitVal = lexer.stringVal();
            MySqlIntervalUnit unit = MySqlIntervalUnit.valueOf(unitVal.toUpperCase());
            lexer.nextToken();
            accept(Token.FROM);
            SQLExpr value = expr();
            MySqlExtractExpr extract = new MySqlExtractExpr();
            extract.setValue(value);
            extract.setUnit(unit);
            accept(Token.RPAREN);
            expr = extract;
            return primaryRest(expr);
        } else if ("SUBSTRING".equalsIgnoreCase(ident)) {
            lexer.nextToken();
            SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);
            for (; ; ) {
                SQLExpr param = expr();
                methodInvokeExpr.addParameter(param);
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                } else if (lexer.token() == Token.FROM) {
                    lexer.nextToken();
                    SQLExpr from = expr();
                    methodInvokeExpr.addParameter(from);
                    if (lexer.token() == Token.FOR) {
                        lexer.nextToken();
                        SQLExpr forExpr = expr();
                        methodInvokeExpr.addParameter(forExpr);
                    }
                    break;
                } else if (lexer.token() == Token.RPAREN) {
                    break;
                } else {
                    throw new ParserException("syntax error");
                }
            }
            accept(Token.RPAREN);
            expr = methodInvokeExpr;
            return primaryRest(expr);
        } else if ("TRIM".equalsIgnoreCase(ident)) {
            lexer.nextToken();
            SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);
            if (lexer.token() == Token.IDENTIFIER) {
                String flagVal = lexer.stringVal();
                if ("LEADING".equalsIgnoreCase(flagVal)) {
                    lexer.nextToken();
                    methodInvokeExpr.getAttributes().put("TRIM_TYPE", "LEADING");
                } else if ("BOTH".equalsIgnoreCase(flagVal)) {
                    lexer.nextToken();
                    methodInvokeExpr.getAttributes().put("TRIM_TYPE", "BOTH");
                } else if ("TRAILING".equalsIgnoreCase(flagVal)) {
                    lexer.nextToken();
                    methodInvokeExpr.putAttribute("TRIM_TYPE", "TRAILING");
                }
            }
            SQLExpr param = expr();
            methodInvokeExpr.addParameter(param);
            if (lexer.token() == Token.FROM) {
                lexer.nextToken();
                SQLExpr from = expr();
                methodInvokeExpr.putAttribute("FROM", from);
            }
            accept(Token.RPAREN);
            expr = methodInvokeExpr;
            return primaryRest(expr);
        } else if ("MATCH".equalsIgnoreCase(ident)) {
            lexer.nextToken();
            MySqlMatchAgainstExpr matchAgainstExpr = new MySqlMatchAgainstExpr();
            if (lexer.token() == Token.RPAREN) {
                lexer.nextToken();
            } else {
                exprList(matchAgainstExpr.getColumns(), matchAgainstExpr);
                accept(Token.RPAREN);
            }
            acceptIdentifier("AGAINST");
            accept(Token.LPAREN);
            SQLExpr against = primary();
            matchAgainstExpr.setAgainst(against);
            if (lexer.token() == Token.IN) {
                lexer.nextToken();
                if (identifierEquals("NATURAL")) {
                    lexer.nextToken();
                    acceptIdentifier("LANGUAGE");
                    acceptIdentifier("MODE");
                    if (lexer.token() == Token.WITH) {
                        lexer.nextToken();
                        acceptIdentifier("QUERY");
                        acceptIdentifier("EXPANSION");
                        matchAgainstExpr.setSearchModifier(SearchModifier.IN_NATURAL_LANGUAGE_MODE_WITH_QUERY_EXPANSION);
                    } else {
                        matchAgainstExpr.setSearchModifier(SearchModifier.IN_NATURAL_LANGUAGE_MODE);
                    }
                } else if (identifierEquals("BOOLEAN")) {
                    lexer.nextToken();
                    acceptIdentifier("MODE");
                    matchAgainstExpr.setSearchModifier(SearchModifier.IN_BOOLEAN_MODE);
                } else {
                    throw new ParserException("TODO");
                }
            } else if (lexer.token() == Token.WITH) {
                throw new ParserException("TODO");
            }
            accept(Token.RPAREN);
            expr = matchAgainstExpr;
            return primaryRest(expr);
        } else if (("CONVERT".equalsIgnoreCase(ident)) || ("CHAR".equalsIgnoreCase(ident))) {
            lexer.nextToken();
            SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);
            if (lexer.token() != Token.RPAREN) {
                exprList(methodInvokeExpr.getParameters(), methodInvokeExpr);
            }
            if (identifierEquals("USING")) {
                lexer.nextToken();
                if (lexer.token() != Token.IDENTIFIER) {
                    throw new ParserException("syntax error");
                }
                String charset = lexer.stringVal();
                lexer.nextToken();
                methodInvokeExpr.putAttribute("USING", charset);
            }
            accept(Token.RPAREN);
            expr = methodInvokeExpr;
            return primaryRest(expr);
        } else if ("POSITION".equalsIgnoreCase(ident)) {
            accept(Token.LPAREN);
            SQLExpr subStr = this.primary();
            accept(Token.IN);
            SQLExpr str = this.expr();
            accept(Token.RPAREN);
            SQLMethodInvokeExpr locate = new SQLMethodInvokeExpr("LOCATE");
            locate.addParameter(subStr);
            locate.addParameter(str);
            expr = locate;
            return primaryRest(expr);
        }
    }
    if (lexer.token() == Token.VARIANT && "@".equals(lexer.stringVal())) {
        lexer.nextToken();
        MySqlUserName userName = new MySqlUserName();
        if (expr instanceof SQLCharExpr) {
            userName.setUserName(((SQLCharExpr) expr).toString());
        } else {
            userName.setUserName(((SQLIdentifierExpr) expr).getName());
        }
        if (lexer.token() == Token.LITERAL_CHARS) {
            userName.setHost("'" + lexer.stringVal() + "'");
        } else {
            userName.setHost(lexer.stringVal());
        }
        lexer.nextToken();
        return userName;
    }
    if (lexer.token() == Token.ERROR) {
        throw new ParserException("syntax error, token: " + lexer.token() + " " + lexer.stringVal() + ", pos : " + lexer.pos());
    }
    return super.primaryRest(expr);
}

Example 13 with SQLIdentifierExpr

use of com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr in project druid by alibaba.

the class MySqlExprParser method parseAssignItem.

public SQLAssignItem parseAssignItem() {
    SQLAssignItem item = new SQLAssignItem();
    SQLExpr var = primary();
    String ident = null;
    if (var instanceof SQLIdentifierExpr) {
        ident = ((SQLIdentifierExpr) var).getName();
        if ("GLOBAL".equalsIgnoreCase(ident)) {
            ident = lexer.stringVal();
            lexer.nextToken();
            var = new SQLVariantRefExpr(ident, true);
        } else if ("SESSION".equalsIgnoreCase(ident)) {
            ident = lexer.stringVal();
            lexer.nextToken();
            var = new SQLVariantRefExpr(ident, false);
        } else {
            var = new SQLVariantRefExpr(ident);
        }
    }
    if ("NAMES".equalsIgnoreCase(ident)) {
    // skip
    } else if ("CHARACTER".equalsIgnoreCase(ident)) {
        var = new SQLIdentifierExpr("CHARACTER SET");
        accept(Token.SET);
        if (lexer.token() == Token.EQ) {
            lexer.nextToken();
        }
    } else {
        if (lexer.token() == Token.COLONEQ) {
            lexer.nextToken();
        } else {
            accept(Token.EQ);
        }
    }
    if (lexer.token() == Token.ON) {
        lexer.nextToken();
        item.setValue(new SQLIdentifierExpr("ON"));
    } else {
        item.setValue(this.expr());
    }
    item.setTarget(var);
    return item;
}

Example 14 with SQLIdentifierExpr

use of com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr in project druid by alibaba.

the class MySqlExprParser method primary.

public SQLExpr primary() {
    final Token tok = lexer.token();
    if (identifierEquals("outfile")) {
        lexer.nextToken();
        SQLExpr file = primary();
        SQLExpr expr = new MySqlOutFileExpr(file);
        return primaryRest(expr);
    }
    switch(tok) {
        case LITERAL_ALIAS:
            String aliasValue = lexer.stringVal();
            lexer.nextToken();
            return primaryRest(new SQLCharExpr(aliasValue));
        case VARIANT:
            SQLVariantRefExpr varRefExpr = new SQLVariantRefExpr(lexer.stringVal());
            lexer.nextToken();
            if (varRefExpr.getName().equalsIgnoreCase("@@global")) {
                accept(Token.DOT);
                varRefExpr = new SQLVariantRefExpr(lexer.stringVal(), true);
                lexer.nextToken();
            } else if (varRefExpr.getName().equals("@") && lexer.token() == Token.LITERAL_CHARS) {
                varRefExpr.setName("@'" + lexer.stringVal() + "'");
                lexer.nextToken();
            } else if (varRefExpr.getName().equals("@@") && lexer.token() == Token.LITERAL_CHARS) {
                varRefExpr.setName("@@'" + lexer.stringVal() + "'");
                lexer.nextToken();
            }
            return primaryRest(varRefExpr);
        case VALUES:
            lexer.nextToken();
            if (lexer.token() != Token.LPAREN) {
                throw new ParserException("syntax error, illegal values clause");
            }
            return this.methodRest(new SQLIdentifierExpr("VALUES"), true);
        case BINARY:
            lexer.nextToken();
            if (lexer.token() == Token.COMMA || lexer.token() == Token.SEMI || lexer.token() == Token.EOF) {
                return new SQLIdentifierExpr("BINARY");
            } else {
                SQLUnaryExpr binaryExpr = new SQLUnaryExpr(SQLUnaryOperator.BINARY, expr());
                return primaryRest(binaryExpr);
            }
        case CACHE:
        case GROUP:
            lexer.nextToken();
            return primaryRest(new SQLIdentifierExpr(lexer.stringVal()));
        default:
            return super.primary();
    }
}

Example 15 with SQLIdentifierExpr

use of com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr in project druid by alibaba.

the class DB2ExprParser method dotRest.

protected SQLExpr dotRest(SQLExpr expr) {
    if (identifierEquals("NEXTVAL")) {
        if (expr instanceof SQLIdentifierExpr) {
            SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
            SQLSequenceExpr seqExpr = new SQLSequenceExpr(identExpr, SQLSequenceExpr.Function.NextVal);
            lexer.nextToken();
            return seqExpr;
        }
    } else if (identifierEquals("PREVVAL")) {
        if (expr instanceof SQLIdentifierExpr) {
            SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
            SQLSequenceExpr seqExpr = new SQLSequenceExpr(identExpr, SQLSequenceExpr.Function.PrevVal);
            lexer.nextToken();
            return seqExpr;
        }
    } else if (identifierEquals("CURRVAL")) {
        if (expr instanceof SQLIdentifierExpr) {
            SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
            SQLSequenceExpr seqExpr = new SQLSequenceExpr(identExpr, SQLSequenceExpr.Function.CurrVal);
            lexer.nextToken();
            return seqExpr;
        }
    }
    return super.dotRest(expr);
}