Examples with ParserException com.alibaba.druid.sql.parser.ParserException used on opensource projects

Example 6 with ParserException

use of com.alibaba.druid.sql.parser.ParserException 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 7 with ParserException

use of com.alibaba.druid.sql.parser.ParserException in project druid by alibaba.

the class MySqlStatementParser method parseSet.

public SQLStatement parseSet() {
    accept(Token.SET);
    if (identifierEquals("PASSWORD")) {
        lexer.nextToken();
        MySqlSetPasswordStatement stmt = new MySqlSetPasswordStatement();
        if (lexer.token() == Token.FOR) {
            lexer.nextToken();
            stmt.setUser(this.exprParser.name());
        }
        accept(Token.EQ);
        stmt.setPassword(this.exprParser.expr());
        return stmt;
    }
    Boolean global = null;
    if (identifierEquals(GLOBAL)) {
        global = Boolean.TRUE;
        lexer.nextToken();
    } else if (identifierEquals(SESSION)) {
        global = Boolean.FALSE;
        lexer.nextToken();
    }
    if (identifierEquals("TRANSACTION")) {
        MySqlSetTransactionStatement stmt = new MySqlSetTransactionStatement();
        stmt.setGlobal(global);
        lexer.nextToken();
        if (identifierEquals("ISOLATION")) {
            lexer.nextToken();
            acceptIdentifier("LEVEL");
            if (identifierEquals(READ)) {
                lexer.nextToken();
                if (identifierEquals("UNCOMMITTED")) {
                    stmt.setIsolationLevel("READ UNCOMMITTED");
                    lexer.nextToken();
                } else if (identifierEquals(WRITE)) {
                    stmt.setIsolationLevel("READ WRITE");
                    lexer.nextToken();
                } else if (identifierEquals("ONLY")) {
                    stmt.setIsolationLevel("READ ONLY");
                    lexer.nextToken();
                } else if (identifierEquals("COMMITTED")) {
                    stmt.setIsolationLevel("READ COMMITTED");
                    lexer.nextToken();
                } else {
                    throw new ParserException("UNKOWN TRANSACTION LEVEL : " + lexer.stringVal());
                }
            } else if (identifierEquals("SERIALIZABLE")) {
                stmt.setIsolationLevel("SERIALIZABLE");
                lexer.nextToken();
            } else if (identifierEquals("REPEATABLE")) {
                lexer.nextToken();
                if (identifierEquals(READ)) {
                    stmt.setIsolationLevel("REPEATABLE READ");
                    lexer.nextToken();
                } else {
                    throw new ParserException("UNKOWN TRANSACTION LEVEL : " + lexer.stringVal());
                }
            } else {
                throw new ParserException("UNKOWN TRANSACTION LEVEL : " + lexer.stringVal());
            }
        } else if (identifierEquals(READ)) {
            lexer.nextToken();
            if (identifierEquals("ONLY")) {
                stmt.setAccessModel("ONLY");
                lexer.nextToken();
            } else if (identifierEquals("WRITE")) {
                stmt.setAccessModel("WRITE");
                lexer.nextToken();
            } else {
                throw new ParserException("UNKOWN ACCESS MODEL : " + lexer.stringVal());
            }
        }
        return stmt;
    } else if (identifierEquals("NAMES")) {
        lexer.nextToken();
        MySqlSetNamesStatement stmt = new MySqlSetNamesStatement();
        if (lexer.token() == Token.DEFAULT) {
            lexer.nextToken();
            stmt.setDefault(true);
        } else {
            String charSet = lexer.stringVal();
            stmt.setCharSet(charSet);
            lexer.nextToken();
            if (identifierEquals(COLLATE2)) {
                lexer.nextToken();
                String collate = lexer.stringVal();
                stmt.setCollate(collate);
                lexer.nextToken();
            }
        }
        return stmt;
    } else if (identifierEquals(CHARACTER)) {
        lexer.nextToken();
        accept(Token.SET);
        MySqlSetCharSetStatement stmt = new MySqlSetCharSetStatement();
        if (lexer.token() == Token.DEFAULT) {
            lexer.nextToken();
            stmt.setDefault(true);
        } else {
            String charSet = lexer.stringVal();
            stmt.setCharSet(charSet);
            lexer.nextToken();
            if (identifierEquals(COLLATE2)) {
                lexer.nextToken();
                String collate = lexer.stringVal();
                stmt.setCollate(collate);
                lexer.nextToken();
            }
        }
        return stmt;
    } else {
        SQLSetStatement stmt = new SQLSetStatement(getDbType());
        parseAssignItems(stmt.getItems(), stmt);
        if (global != null && global.booleanValue()) {
            SQLVariantRefExpr varRef = (SQLVariantRefExpr) stmt.getItems().get(0).getTarget();
            varRef.setGlobal(true);
        }
        if (lexer.token() == Token.HINT) {
            stmt.setHints(this.exprParser.parseHints());
        }
        return stmt;
    }
}

Example 8 with ParserException

use of com.alibaba.druid.sql.parser.ParserException in project druid by alibaba.

the class MySqlStatementParser method parseCreateIndexUsing.

private void parseCreateIndexUsing(SQLCreateIndexStatement stmt) {
    if (identifierEquals("USING")) {
        lexer.nextToken();
        if (identifierEquals("BTREE")) {
            stmt.setUsing("BTREE");
            lexer.nextToken();
        } else if (identifierEquals("HASH")) {
            stmt.setUsing("HASH");
            lexer.nextToken();
        } else {
            throw new ParserException("TODO " + lexer.token() + " " + lexer.stringVal());
        }
    }
}

Example 9 with ParserException

use of com.alibaba.druid.sql.parser.ParserException in project druid by alibaba.

the class MySqlStatementParser method parseValueClause.

private void parseValueClause(List<ValuesClause> valueClauseList, int columnSize) {
    for (int i = 0; ; ++i) {
        if (lexer.token() != Token.LPAREN) {
            throw new ParserException("syntax error, expect ')'");
        }
        lexer.nextTokenValue();
        if (lexer.token() != Token.RPAREN) {
            List<SQLExpr> valueExprList;
            if (columnSize > 0) {
                valueExprList = new ArrayList<SQLExpr>(columnSize);
            } else {
                valueExprList = new ArrayList<SQLExpr>();
            }
            for (; ; ) {
                SQLExpr expr;
                if (lexer.token() == Token.LITERAL_INT) {
                    expr = new SQLIntegerExpr(lexer.integerValue());
                    lexer.nextTokenComma();
                } else if (lexer.token() == Token.LITERAL_CHARS) {
                    expr = new SQLCharExpr(lexer.stringVal());
                    lexer.nextTokenComma();
                } else if (lexer.token() == Token.LITERAL_NCHARS) {
                    expr = new SQLNCharExpr(lexer.stringVal());
                    lexer.nextTokenComma();
                } else {
                    expr = exprParser.expr();
                }
                if (lexer.token() == Token.COMMA) {
                    valueExprList.add(expr);
                    lexer.nextTokenValue();
                    continue;
                } else if (lexer.token() == Token.RPAREN) {
                    valueExprList.add(expr);
                    break;
                } else {
                    expr = this.exprParser.primaryRest(expr);
                    if (lexer.token() != Token.COMMA && lexer.token() != Token.RPAREN) {
                        expr = this.exprParser.exprRest(expr);
                    }
                    valueExprList.add(expr);
                    if (lexer.token() == Token.COMMA) {
                        lexer.nextToken();
                        continue;
                    } else {
                        break;
                    }
                }
            }
            SQLInsertStatement.ValuesClause values = new SQLInsertStatement.ValuesClause(valueExprList);
            valueClauseList.add(values);
        } else {
            SQLInsertStatement.ValuesClause values = new SQLInsertStatement.ValuesClause(new ArrayList<SQLExpr>(0));
            valueClauseList.add(values);
        }
        if (lexer.token() != Token.RPAREN) {
            throw new ParserException("syntax error");
        }
        if (!parseCompleteValues && valueClauseList.size() >= parseValuesSize) {
            lexer.skipToEOF();
            break;
        }
        lexer.nextTokenComma();
        if (lexer.token() == Token.COMMA) {
            lexer.nextTokenLParen();
            continue;
        } else {
            break;
        }
    }
}

Example 10 with ParserException

use of com.alibaba.druid.sql.parser.ParserException in project druid by alibaba.

the class MySqlStatementParser method parseSpStatement.

/**
     * zhujun [455910092@qq.com]
     * parse spstatement
     * @return
     */
public SQLStatement parseSpStatement() {
    // update
    if (lexer.token() == (Token.UPDATE)) {
        return parseUpdateStatement();
    }
    // create
    if (lexer.token() == (Token.CREATE)) {
        return parseCreate();
    }
    // insert
    if (lexer.token() == Token.INSERT) {
        return parseInsert();
    }
    // delete
    if (lexer.token() == (Token.DELETE)) {
        return parseDeleteStatement();
    }
    // begin
    if (lexer.token() == Token.BEGIN) {
        return this.parseBlock();
    }
    // select
    if (lexer.token() == Token.LPAREN) {
        char ch = lexer.current();
        int bp = lexer.bp();
        lexer.nextToken();
        if (lexer.token() == Token.SELECT) {
            lexer.reset(bp, ch, Token.LPAREN);
            return this.parseSelect();
        } else {
            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
        }
    }
    // assign statement
    if (lexer.token() == Token.SET) {
        return parseAssign();
    }
    throw new ParserException("error sp_statement");
}