Java Token类代码示例

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
protected SQLExpr dotRest(SQLExpr expr) {
    boolean backet = false;

    if (lexer.token() == Token.LBRACKET) {
        lexer.nextToken();
        backet = true;
    }

    expr = super.dotRest(expr);

    if (backet) {
        accept(Token.RBRACKET);
    }

    return expr;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
protected SQLPartitionByRange partitionByRange() {
    acceptIdentifier("RANGE");

    SQLPartitionByRange clause = new SQLPartitionByRange();

    if (lexer.token() == Token.LPAREN) {
        lexer.nextToken();
        clause.setExpr(this.exprParser.expr());
        accept(Token.RPAREN);
    } else {
        acceptIdentifier("COLUMNS");
        accept(Token.LPAREN);
        for (;;) {
            clause.addColumn(this.exprParser.name());
            if (lexer.token() == Token.COMMA) {
                lexer.nextToken();
                continue;
            }
            break;
        }
        accept(Token.RPAREN);
    }
    return clause;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
protected SQLTableSource parseLateralView(SQLTableSource tableSource) {
    accept(Token.VIEW);
    if ("LATERAL".equalsIgnoreCase(tableSource.getAlias())) {
        tableSource.setAlias(null);
    }
    OdpsLateralViewTableSource lateralViewTabSrc = new OdpsLateralViewTableSource();
    lateralViewTabSrc.setTableSource(tableSource);
    
    SQLMethodInvokeExpr udtf = (SQLMethodInvokeExpr) this.exprParser.expr();
    lateralViewTabSrc.setMethod(udtf);
    
    String alias = as();
    lateralViewTabSrc.setAlias(alias);
    
    accept(Token.AS);
    
    this.exprParser.names(lateralViewTabSrc.getColumns());
    
    return parseTableSourceRest(lateralViewTabSrc);
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public SQLExpr primaryRest(SQLExpr expr) {
    if(lexer.token() == Token.COLON) {
        lexer.nextToken();
        expr = dotRest(expr);
        return expr;
    }
    
    if (lexer.token() == Token.LBRACKET) {
        SQLArrayExpr array = new SQLArrayExpr();
        array.setExpr(expr);
        lexer.nextToken();
        this.exprList(array.getValues(), array);
        accept(Token.RBRACKET);
        return primaryRest(array);
    }
    
    return super.primaryRest(expr);
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public boolean parseStatementListDialect(List<SQLStatement> statementList) {
    if (lexer.token() == Token.VALUES) {
        lexer.nextToken();
        DB2ValuesStatement stmt = new DB2ValuesStatement();
        stmt.setExpr(this.exprParser.expr());
        statementList.add(stmt);
        return true;
    }
    
    return false;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
@Override
protected void parseInsertColumns(SQLInsertInto insert) {
    if (lexer.token() == Token.RPAREN ) {
        return;
    }

    for (;;) {
        SQLName expr = this.exprParser.name();
        expr.setParent(insert);
        insert.getColumns().add(expr);

        if (lexer.token() == Token.IDENTIFIER) {
            String text = lexer.stringVal();
            if (text.equalsIgnoreCase("TINYINT")
                || text.equalsIgnoreCase("BIGINT")
                || text.equalsIgnoreCase("INTEGER")
                || text.equalsIgnoreCase("DOUBLE")
                || text.equalsIgnoreCase("DATE")
                || text.equalsIgnoreCase("VARCHAR")) {
                expr.getAttributes().put("dataType", text);
                lexer.nextToken();
            } else if (text.equalsIgnoreCase("CHAR")) {
                String dataType = text;
                lexer.nextToken();
                accept(Token.LPAREN);
                SQLExpr char_len = this.exprParser.primary();
                accept(Token.RPAREN);
                dataType += ("(" + char_len.toString() + ")");
                expr.getAttributes().put("dataType", dataType);
            }
        }

        if (lexer.token() == Token.COMMA) {
            lexer.nextToken();
            continue;
        }

        break;
    }
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
@Override
public SQLDataType parseDataType() {
    if (lexer.token() == Token.TYPE) {
        lexer.nextToken();
    }
    return super.parseDataType();
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
@Override
protected SQLExpr parseInterval() {
    accept(Token.INTERVAL);
    PGIntervalExpr intervalExpr=new PGIntervalExpr();
    if (lexer.token() != Token.LITERAL_CHARS) {
        return new SQLIdentifierExpr("INTERVAL");
    }
    intervalExpr.setValue(new SQLCharExpr(lexer.stringVal()));
    lexer.nextToken();
    return intervalExpr;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public SQLExpr primary() {

        if (lexer.token() == Token.LBRACKET) {
            lexer.nextToken();
            SQLExpr name = this.name();
            accept(Token.RBRACKET);
            return primaryRest(name);
        }

        return super.primary();
    }
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public SQLExpr primaryRest(SQLExpr expr) {
    if (lexer.token() == Token.DOTDOT) {
        expr = nameRest((SQLName) expr);
    }

    return super.primaryRest(expr);
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public SQLServerTop parseTop() {
    if (lexer.token() == Token.TOP) {
        SQLServerTop top = new SQLServerTop();
        lexer.nextToken();

        boolean paren = false;
        if (lexer.token() == Token.LPAREN) {
            paren = true;
            lexer.nextToken();
        }

        top.setExpr(primary());

        if (paren) {
            accept(Token.RPAREN);
        }

        if (lexer.token() == Token.PERCENT) {
            lexer.nextToken();
            top.setPercent(true);
        }

        return top;
    }

    return null;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
protected SQLServerOutput parserOutput() {
    if (lexer.identifierEquals("OUTPUT")) {
        lexer.nextToken();
        SQLServerOutput output = new SQLServerOutput();

        final List<SQLSelectItem> selectList = output.getSelectList();
        for (;;) {
            final SQLSelectItem selectItem = parseSelectItem();
            selectList.add(selectItem);

            if (lexer.token() != Token.COMMA) {
                break;
            }

            lexer.nextToken();
        }

        if (lexer.token() == Token.INTO) {
            lexer.nextToken();
            output.setInto(new SQLExprTableSource(this.name()));
            if (lexer.token() == (Token.LPAREN)) {
                lexer.nextToken();
                this.exprList(output.getColumns(), output);
                accept(Token.RPAREN);
            }
        }
        return output;
    }
    return null;
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) {
    if (lexer.token() == Token.IDENTITY) {
        lexer.nextToken();

        SQLColumnDefinition.Identity identity = new SQLColumnDefinition.Identity();
        if (lexer.token() == Token.LPAREN) {
            lexer.nextToken();

            SQLIntegerExpr seed = (SQLIntegerExpr) this.primary();
            accept(Token.COMMA);
            SQLIntegerExpr increment = (SQLIntegerExpr) this.primary();
            accept(Token.RPAREN);
            
            identity.setSeed((Integer) seed.getNumber());
            identity.setIncrement((Integer) increment.getNumber());
        }

        if (lexer.token() == Token.NOT) {
            lexer.nextToken();

            if (lexer.token() == Token.NULL) {
                lexer.nextToken();
                column.setDefaultExpr(new SQLNullExpr());
            } else {
                accept(Token.FOR);
                acceptIdentifier("REPLICATION ");
                identity.setNotForReplication(true);
            }
        }

        column.setIdentity(identity);
    }

    return super.parseColumnRest(column);
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
private void parseIndexHint(MySqlIndexHintImpl hint) {
    if (lexer.token() == Token.INDEX) {
        lexer.nextToken();
    } else {
        accept(Token.KEY);
    }

    if (lexer.token() == Token.FOR) {
        lexer.nextToken();

        if (lexer.token() == Token.JOIN) {
            lexer.nextToken();
            hint.setOption(MySqlIndexHint.Option.JOIN);
        } else if (lexer.token() == Token.ORDER) {
            lexer.nextToken();
            accept(Token.BY);
            hint.setOption(MySqlIndexHint.Option.ORDER_BY);
        } else {
            accept(Token.GROUP);
            accept(Token.BY);
            hint.setOption(MySqlIndexHint.Option.GROUP_BY);
        }
    }

    accept(Token.LPAREN);
    if (lexer.token() == Token.PRIMARY) {
        lexer.nextToken();
        hint.getIndexList().add(new SQLIdentifierExpr("PRIMARY"));
    } else {
        this.exprParser.names(hint.getIndexList());
    }
    accept(Token.RPAREN);
}
 

import com.alibaba.druid.sql.parser.Token; //导入依赖的package包/类
private boolean parseTableOptionCharsetOrCollate(MySqlCreateTableStatement stmt) {
    if (lexer.identifierEquals("CHARACTER")) {
        lexer.nextToken();
        accept(Token.SET);
        if (lexer.token() == Token.EQ) {
            lexer.nextToken();
        }
        stmt.getTableOptions().put("CHARACTER SET", this.exprParser.expr());
        return true;
    }

    if (lexer.identifierEquals("CHARSET")) {
        lexer.nextToken();
        if (lexer.token() == Token.EQ) {
            lexer.nextToken();
        }
        stmt.getTableOptions().put("CHARSET", this.exprParser.expr());
        return true;
    }

    if (lexer.identifierEquals("COLLATE")) {
        lexer.nextToken();
        if (lexer.token() == Token.EQ) {
            lexer.nextToken();
        }
        stmt.getTableOptions().put("COLLATE", this.exprParser.expr());
        return true;
    }

    return false;
}