Examples with Expression com.alibaba.cobar.parser.ast.expression.Expression used on opensource projects

Example 6 with Expression

use of com.alibaba.cobar.parser.ast.expression.Expression in project cobar by alibaba.

the class MySQLDALParser method show.

public DALShowStatement show() throws SQLSyntaxErrorException {
    match(KW_SHOW);
    String tempStr;
    String tempStrUp;
    Expression tempExpr;
    Identifier tempId;
    SpecialIdentifier tempSi;
    Limit tempLimit;
    switch(lexer.token()) {
        case KW_BINARY:
            lexer.nextToken();
            matchIdentifier("LOGS");
            return new ShowBinaryLog();
        case KW_CHARACTER:
            lexer.nextToken();
            match(KW_SET);
            switch(lexer.token()) {
                case KW_LIKE:
                    tempStr = like();
                    return new ShowCharaterSet(tempStr);
                case KW_WHERE:
                    tempExpr = where();
                    return new ShowCharaterSet(tempExpr);
                default:
                    return new ShowCharaterSet();
            }
        case KW_CREATE:
            ShowCreate.Type showCreateType;
            switch1: switch(lexer.nextToken()) {
                case KW_DATABASE:
                    showCreateType = ShowCreate.Type.DATABASE;
                    break;
                case KW_PROCEDURE:
                    showCreateType = ShowCreate.Type.PROCEDURE;
                    break;
                case KW_TABLE:
                    showCreateType = ShowCreate.Type.TABLE;
                    break;
                case KW_TRIGGER:
                    showCreateType = ShowCreate.Type.TRIGGER;
                    break;
                case IDENTIFIER:
                    tempSi = specialIdentifiers.get(lexer.stringValueUppercase());
                    if (tempSi != null) {
                        switch(tempSi) {
                            case EVENT:
                                showCreateType = ShowCreate.Type.EVENT;
                                break switch1;
                            case FUNCTION:
                                showCreateType = ShowCreate.Type.FUNCTION;
                                break switch1;
                            case VIEW:
                                showCreateType = ShowCreate.Type.VIEW;
                                break switch1;
                        }
                    }
                default:
                    throw err("unexpect token for SHOW CREATE");
            }
            lexer.nextToken();
            tempId = identifier();
            return new ShowCreate(showCreateType, tempId);
        case KW_SCHEMAS:
        case KW_DATABASES:
            lexer.nextToken();
            switch(lexer.token()) {
                case KW_LIKE:
                    tempStr = like();
                    return new ShowDatabases(tempStr);
                case KW_WHERE:
                    tempExpr = where();
                    return new ShowDatabases(tempExpr);
            }
            return new ShowDatabases();
        case KW_KEYS:
            return showIndex(ShowIndex.Type.KEYS);
        case KW_INDEX:
            return showIndex(ShowIndex.Type.INDEX);
        case KW_PROCEDURE:
            lexer.nextToken();
            tempStrUp = lexer.stringValueUppercase();
            tempSi = specialIdentifiers.get(tempStrUp);
            if (tempSi != null) {
                switch(tempSi) {
                    case CODE:
                        lexer.nextToken();
                        tempId = identifier();
                        return new ShowProcedureCode(tempId);
                    case STATUS:
                        switch(lexer.nextToken()) {
                            case KW_LIKE:
                                tempStr = like();
                                return new ShowProcedureStatus(tempStr);
                            case KW_WHERE:
                                tempExpr = where();
                                return new ShowProcedureStatus(tempExpr);
                            default:
                                return new ShowProcedureStatus();
                        }
                }
            }
            throw err("unexpect token for SHOW PROCEDURE");
        case KW_TABLE:
            lexer.nextToken();
            matchIdentifier("STATUS");
            tempId = null;
            if (lexer.token() == KW_FROM || lexer.token() == KW_IN) {
                lexer.nextToken();
                tempId = identifier();
            }
            switch(lexer.token()) {
                case KW_LIKE:
                    tempStr = like();
                    return new ShowTableStatus(tempId, tempStr);
                case KW_WHERE:
                    tempExpr = where();
                    return new ShowTableStatus(tempId, tempExpr);
            }
            return new ShowTableStatus(tempId);
        case IDENTIFIER:
            tempStrUp = lexer.stringValueUppercase();
            tempSi = specialIdentifiers.get(tempStrUp);
            if (tempSi == null) {
                break;
            }
            switch(tempSi) {
                case INDEXES:
                    return showIndex(ShowIndex.Type.INDEXES);
                case GRANTS:
                    if (lexer.nextToken() == KW_FOR) {
                        lexer.nextToken();
                        tempExpr = exprParser.expression();
                        return new ShowGrants(tempExpr);
                    }
                    return new ShowGrants();
                case AUTHORS:
                    lexer.nextToken();
                    return new ShowAuthors();
                case BINLOG:
                    lexer.nextToken();
                    matchIdentifier("EVENTS");
                    tempStr = null;
                    tempExpr = null;
                    tempLimit = null;
                    if (lexer.token() == KW_IN) {
                        lexer.nextToken();
                        tempStr = lexer.stringValue();
                        lexer.nextToken();
                    }
                    if (lexer.token() == KW_FROM) {
                        lexer.nextToken();
                        tempExpr = exprParser.expression();
                    }
                    if (lexer.token() == KW_LIMIT) {
                        tempLimit = limit();
                    }
                    return new ShowBinLogEvent(tempStr, tempExpr, tempLimit);
                case COLLATION:
                    switch(lexer.nextToken()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowCollation(tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowCollation(tempExpr);
                    }
                    return new ShowCollation();
                case COLUMNS:
                    return showColumns(false);
                case CONTRIBUTORS:
                    lexer.nextToken();
                    return new ShowContributors();
                case ENGINE:
                    switch(lexer.nextToken()) {
                        case IDENTIFIER:
                            tempStrUp = lexer.stringValueUppercase();
                            tempSi = specialIdentifiers.get(tempStrUp);
                            if (tempSi != null) {
                                switch(tempSi) {
                                    case INNODB:
                                        lexer.nextToken();
                                        tempStrUp = lexer.stringValueUppercase();
                                        tempSi = specialIdentifiers.get(tempStrUp);
                                        if (tempSi != null) {
                                            switch(tempSi) {
                                                case STATUS:
                                                    lexer.nextToken();
                                                    return new ShowEngine(ShowEngine.Type.INNODB_STATUS);
                                                case MUTEX:
                                                    lexer.nextToken();
                                                    return new ShowEngine(ShowEngine.Type.INNODB_MUTEX);
                                            }
                                        }
                                    case PERFORMANCE_SCHEMA:
                                        lexer.nextToken();
                                        matchIdentifier("STATUS");
                                        return new ShowEngine(ShowEngine.Type.PERFORMANCE_SCHEMA_STATUS);
                                }
                            }
                        default:
                            throw err("unexpect token for SHOW ENGINE");
                    }
                case ENGINES:
                    lexer.nextToken();
                    return new ShowEngines();
                case ERRORS:
                    lexer.nextToken();
                    tempLimit = limit();
                    return new ShowErrors(false, tempLimit);
                case COUNT:
                    lexer.nextToken();
                    match(PUNC_LEFT_PAREN);
                    match(OP_ASTERISK);
                    match(PUNC_RIGHT_PAREN);
                    switch(matchIdentifier("ERRORS", "WARNINGS")) {
                        case 0:
                            return new ShowErrors(true, null);
                        case 1:
                            return new ShowWarnings(true, null);
                    }
                case EVENTS:
                    tempId = null;
                    switch(lexer.nextToken()) {
                        case KW_IN:
                        case KW_FROM:
                            lexer.nextToken();
                            tempId = identifier();
                    }
                    switch(lexer.token()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowEvents(tempId, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowEvents(tempId, tempExpr);
                        default:
                            return new ShowEvents(tempId);
                    }
                case FULL:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null) {
                        switch(tempSi) {
                            case COLUMNS:
                                return showColumns(true);
                            case PROCESSLIST:
                                lexer.nextToken();
                                return new ShowProcesslist(true);
                            case TABLES:
                                tempId = null;
                                switch(lexer.nextToken()) {
                                    case KW_IN:
                                    case KW_FROM:
                                        lexer.nextToken();
                                        tempId = identifier();
                                }
                                switch(lexer.token()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowTables(true, tempId, tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowTables(true, tempId, tempExpr);
                                    default:
                                        return new ShowTables(true, tempId);
                                }
                        }
                    }
                    throw err("unexpected token for SHOW FULL");
                case FUNCTION:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null) {
                        switch(tempSi) {
                            case CODE:
                                lexer.nextToken();
                                tempId = identifier();
                                return new ShowFunctionCode(tempId);
                            case STATUS:
                                switch(lexer.nextToken()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowFunctionStatus(tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowFunctionStatus(tempExpr);
                                    default:
                                        return new ShowFunctionStatus();
                                }
                        }
                    }
                    throw err("unexpected token for SHOW FUNCTION");
                case GLOBAL:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null) {
                        switch(tempSi) {
                            case STATUS:
                                switch(lexer.nextToken()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowStatus(VariableScope.GLOBAL, tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowStatus(VariableScope.GLOBAL, tempExpr);
                                    default:
                                        return new ShowStatus(VariableScope.GLOBAL);
                                }
                            case VARIABLES:
                                switch(lexer.nextToken()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowVariables(VariableScope.GLOBAL, tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowVariables(VariableScope.GLOBAL, tempExpr);
                                    default:
                                        return new ShowVariables(VariableScope.GLOBAL);
                                }
                        }
                    }
                    throw err("unexpected token for SHOW GLOBAL");
                case MASTER:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null && tempSi == SpecialIdentifier.STATUS) {
                        lexer.nextToken();
                        return new ShowMasterStatus();
                    }
                    matchIdentifier("LOGS");
                    return new ShowBinaryLog();
                case OPEN:
                    lexer.nextToken();
                    matchIdentifier("TABLES");
                    tempId = null;
                    switch(lexer.token()) {
                        case KW_IN:
                        case KW_FROM:
                            lexer.nextToken();
                            tempId = identifier();
                    }
                    switch(lexer.token()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowOpenTables(tempId, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowOpenTables(tempId, tempExpr);
                        default:
                            return new ShowOpenTables(tempId);
                    }
                case PLUGINS:
                    lexer.nextToken();
                    return new ShowPlugins();
                case PRIVILEGES:
                    lexer.nextToken();
                    return new ShowPrivileges();
                case PROCESSLIST:
                    lexer.nextToken();
                    return new ShowProcesslist(false);
                case PROFILE:
                    return showProfile();
                case PROFILES:
                    lexer.nextToken();
                    return new ShowProfiles();
                case LOCAL:
                case SESSION:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null) {
                        switch(tempSi) {
                            case STATUS:
                                switch(lexer.nextToken()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowStatus(VariableScope.SESSION, tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowStatus(VariableScope.SESSION, tempExpr);
                                    default:
                                        return new ShowStatus(VariableScope.SESSION);
                                }
                            case VARIABLES:
                                switch(lexer.nextToken()) {
                                    case KW_LIKE:
                                        tempStr = like();
                                        return new ShowVariables(VariableScope.SESSION, tempStr);
                                    case KW_WHERE:
                                        tempExpr = where();
                                        return new ShowVariables(VariableScope.SESSION, tempExpr);
                                    default:
                                        return new ShowVariables(VariableScope.SESSION);
                                }
                        }
                    }
                    throw err("unexpected token for SHOW SESSION");
                case SLAVE:
                    lexer.nextToken();
                    tempStrUp = lexer.stringValueUppercase();
                    tempSi = specialIdentifiers.get(tempStrUp);
                    if (tempSi != null) {
                        switch(tempSi) {
                            case HOSTS:
                                lexer.nextToken();
                                return new ShowSlaveHosts();
                            case STATUS:
                                lexer.nextToken();
                                return new ShowSlaveStatus();
                        }
                    }
                    throw err("unexpected token for SHOW SLAVE");
                case STATUS:
                    switch(lexer.nextToken()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowStatus(VariableScope.SESSION, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowStatus(VariableScope.SESSION, tempExpr);
                        default:
                            return new ShowStatus(VariableScope.SESSION);
                    }
                case STORAGE:
                    lexer.nextToken();
                    matchIdentifier("ENGINES");
                    return new ShowEngines();
                case TABLES:
                    tempId = null;
                    switch(lexer.nextToken()) {
                        case KW_IN:
                        case KW_FROM:
                            lexer.nextToken();
                            tempId = identifier();
                    }
                    switch(lexer.token()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowTables(false, tempId, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowTables(false, tempId, tempExpr);
                        default:
                            return new ShowTables(false, tempId);
                    }
                case TRIGGERS:
                    tempId = null;
                    switch(lexer.nextToken()) {
                        case KW_IN:
                        case KW_FROM:
                            lexer.nextToken();
                            tempId = identifier();
                    }
                    switch(lexer.token()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowTriggers(tempId, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowTriggers(tempId, tempExpr);
                        default:
                            return new ShowTriggers(tempId);
                    }
                case VARIABLES:
                    switch(lexer.nextToken()) {
                        case KW_LIKE:
                            tempStr = like();
                            return new ShowVariables(VariableScope.SESSION, tempStr);
                        case KW_WHERE:
                            tempExpr = where();
                            return new ShowVariables(VariableScope.SESSION, tempExpr);
                        default:
                            return new ShowVariables(VariableScope.SESSION);
                    }
                case WARNINGS:
                    lexer.nextToken();
                    tempLimit = limit();
                    return new ShowWarnings(false, tempLimit);
            }
            break;
    }
    throw err("unexpect token for SHOW");
}

Example 7 with Expression

use of com.alibaba.cobar.parser.ast.expression.Expression in project cobar by alibaba.

the class MySQLDALParser method showProfile.

private ShowProfile showProfile() throws SQLSyntaxErrorException {
    lexer.nextToken();
    List<ShowProfile.Type> types = new LinkedList<ShowProfile.Type>();
    ShowProfile.Type type = showPrifileType();
    if (type == null) {
        types = Collections.emptyList();
    } else if (lexer.token() == PUNC_COMMA) {
        types = new LinkedList<ShowProfile.Type>();
        types.add(type);
        for (; lexer.token() == PUNC_COMMA; ) {
            lexer.nextToken();
            type = showPrifileType();
            types.add(type);
        }
    } else {
        types = new ArrayList<ShowProfile.Type>();
        types.add(type);
    }
    Expression forQuery = null;
    if (lexer.token() == KW_FOR) {
        lexer.nextToken();
        matchIdentifier("QUERY");
        forQuery = exprParser.expression();
    }
    Limit limit = limit();
    return new ShowProfile(types, forQuery, limit);
}

Example 8 with Expression

use of com.alibaba.cobar.parser.ast.expression.Expression in project cobar by alibaba.

the class MySQLDMLCallParser method call.

public DMLCallStatement call() throws SQLSyntaxErrorException {
    match(KW_CALL);
    Identifier procedure = identifier();
    match(PUNC_LEFT_PAREN);
    if (lexer.token() == PUNC_RIGHT_PAREN) {
        lexer.nextToken();
        return new DMLCallStatement(procedure);
    }
    List<Expression> arguments;
    Expression expr = exprParser.expression();
    switch(lexer.token()) {
        case PUNC_COMMA:
            arguments = new LinkedList<Expression>();
            arguments.add(expr);
            for (; lexer.token() == PUNC_COMMA; ) {
                lexer.nextToken();
                expr = exprParser.expression();
                arguments.add(expr);
            }
            match(PUNC_RIGHT_PAREN);
            return new DMLCallStatement(procedure, arguments);
        case PUNC_RIGHT_PAREN:
            lexer.nextToken();
            arguments = new ArrayList<Expression>(1);
            arguments.add(expr);
            return new DMLCallStatement(procedure, arguments);
        default:
            throw err("expect ',' or ')' after first argument of procedure");
    }
}

Example 9 with Expression

use of com.alibaba.cobar.parser.ast.expression.Expression in project cobar by alibaba.

the class MySQLDMLInsertReplaceParser method rowValue.

/**
 * first token is <code>(</code>
 */
private List<Expression> rowValue() throws SQLSyntaxErrorException {
    match(PUNC_LEFT_PAREN);
    if (lexer.token() == PUNC_RIGHT_PAREN) {
        return Collections.emptyList();
    }
    List<Expression> row;
    Expression expr = exprParser.expression();
    if (lexer.token() == PUNC_COMMA) {
        row = new LinkedList<Expression>();
        row.add(expr);
        for (; lexer.token() == PUNC_COMMA; ) {
            lexer.nextToken();
            expr = exprParser.expression();
            row.add(expr);
        }
    } else {
        row = new ArrayList<Expression>(1);
        row.add(expr);
    }
    match(PUNC_RIGHT_PAREN);
    return row;
}

Example 10 with Expression

use of com.alibaba.cobar.parser.ast.expression.Expression in project cobar by alibaba.

the class MySQLDMLReplaceParser method replace.

/**
 * nothing has been pre-consumed <code><pre>
 * 'REPLACE' ('LOW_PRIORITY' | 'DELAYED')? ('INTO')? tableName
 *  (  'SET' colName ('='|':=') (expr|'DEFAULT') (',' colName ('='|':=') (expr|'DEFAULT'))*
 *   | '(' (  colName (','colName)* ')' (  '(' 'SELECT' ... ')'
 *                                       | 'SELECT' ...
 *                                       |('VALUES'|'VALUE') value ( ',' value )*
 *                                      )
 *          | 'SELECT' ... ')'
 *         )
 *   | 'SELECT' ...
 *   |('VALUES'|'VALUE') value ( ',' value )*
 *  )
 * value := '(' (expr|'DEFAULT') ( ',' (expr|'DEFAULT'))* ')'
 * </pre></code>
 */
public DMLReplaceStatement replace() throws SQLSyntaxErrorException {
    match(KW_REPLACE);
    DMLReplaceStatement.ReplaceMode mode = DMLReplaceStatement.ReplaceMode.UNDEF;
    switch(lexer.token()) {
        case KW_LOW_PRIORITY:
            lexer.nextToken();
            mode = DMLReplaceStatement.ReplaceMode.LOW;
            break;
        case KW_DELAYED:
            lexer.nextToken();
            mode = DMLReplaceStatement.ReplaceMode.DELAY;
            break;
    }
    if (lexer.token() == KW_INTO) {
        lexer.nextToken();
    }
    Identifier table = identifier();
    List<Identifier> columnNameList;
    List<RowExpression> rowList;
    QueryExpression select;
    List<Expression> tempRowValue;
    switch(lexer.token()) {
        case KW_SET:
            lexer.nextToken();
            columnNameList = new LinkedList<Identifier>();
            tempRowValue = new LinkedList<Expression>();
            for (; ; lexer.nextToken()) {
                Identifier id = identifier();
                match(OP_EQUALS, OP_ASSIGN);
                Expression expr = exprParser.expression();
                columnNameList.add(id);
                tempRowValue.add(expr);
                if (lexer.token() != PUNC_COMMA) {
                    break;
                }
            }
            rowList = new ArrayList<RowExpression>(1);
            rowList.add(new RowExpression(tempRowValue));
            return new DMLReplaceStatement(mode, table, columnNameList, rowList);
        case IDENTIFIER:
            if (!"VALUE".equals(lexer.stringValueUppercase())) {
                break;
            }
        case KW_VALUES:
            lexer.nextToken();
            columnNameList = null;
            rowList = rowList();
            return new DMLReplaceStatement(mode, table, columnNameList, rowList);
        case KW_SELECT:
            columnNameList = null;
            select = select();
            return new DMLReplaceStatement(mode, table, columnNameList, select);
        case PUNC_LEFT_PAREN:
            switch(lexer.nextToken()) {
                case PUNC_LEFT_PAREN:
                case KW_SELECT:
                    columnNameList = null;
                    select = selectPrimary();
                    match(PUNC_RIGHT_PAREN);
                    return new DMLReplaceStatement(mode, table, columnNameList, select);
            }
            columnNameList = idList();
            match(PUNC_RIGHT_PAREN);
            switch(lexer.token()) {
                case PUNC_LEFT_PAREN:
                case KW_SELECT:
                    select = selectPrimary();
                    return new DMLReplaceStatement(mode, table, columnNameList, select);
                case KW_VALUES:
                    lexer.nextToken();
                    break;
                default:
                    matchIdentifier("VALUE");
            }
            rowList = rowList();
            return new DMLReplaceStatement(mode, table, columnNameList, rowList);
    }
    throw err("unexpected token for replace: " + lexer.token());
}