Java Token.COMMA属性代码示例

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;
}
 

@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;
    }
}
 

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;
}
 

public SQLTableSource parseTableSource() {
    if (lexer.token() == Token.VALUES) {
        lexer.nextToken();
        OdpsValuesTableSource tableSource = new OdpsValuesTableSource();

        for (;;) {
            accept(Token.LPAREN);
            SQLListExpr listExpr = new SQLListExpr();
            this.exprParser.exprList(listExpr.getItems(), listExpr);
            accept(Token.RPAREN);

            listExpr.setParent(tableSource);

            tableSource.getValues().add(listExpr);

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

        String alias = this.tableAlias();
        tableSource.setAlias(alias);

        accept(Token.LPAREN);
        this.exprParser.names(tableSource.getColumns(), tableSource);
        accept(Token.RPAREN);

        return tableSource;
    }

    return super.parseTableSource();
}
 

@Override
public SQLSelectItem parseSelectItem() {
    SQLExpr expr;
    if (lexer.token() == Token.IDENTIFIER) {
        expr = new SQLIdentifierExpr(lexer.stringVal());
        lexer.nextTokenComma();

        if (lexer.token() != Token.COMMA) {
            expr = this.primaryRest(expr);
            expr = this.exprRest(expr);
        }
    } else {
        expr = expr();
    }

    String alias = null;
    if (lexer.token() == Token.AS) {
        lexer.nextToken();

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

            OdpsUDTFSQLSelectItem selectItem = new OdpsUDTFSQLSelectItem();

            selectItem.setExpr(expr);

            for (;;) {
                alias = lexer.stringVal();
                lexer.nextToken();

                selectItem.getAliasList().add(alias);

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

            accept(Token.RPAREN);

            return selectItem;
        } else {
            alias = alias();
        }
    } else {
        alias = as();
    }
    
    SQLSelectItem item = new SQLSelectItem(expr, alias);
    
    if (lexer.hasComment() && lexer.isKeepComments()) {
        item.addAfterComment(lexer.readAndResetComments());
    }

    return item;
}
 

protected void parseGroupBy(SQLSelectQueryBlock queryBlock) {
    SQLSelectGroupByClause groupBy = null;

    if (lexer.token() == Token.GROUP) {
        groupBy = new SQLSelectGroupByClause();

        lexer.nextToken();
        accept(Token.BY);

        while (true) {
            groupBy.addItem(this.getExprParser().parseSelectGroupByItem());
            if (!(lexer.token() == (Token.COMMA))) {
                break;
            }
            lexer.nextToken();
        }

        if (lexer.token() == Token.WITH) {
            lexer.nextToken();
            acceptIdentifier("ROLLUP");

            MySqlSelectGroupBy mySqlGroupBy = new MySqlSelectGroupBy();
            for (SQLExpr sqlExpr : groupBy.getItems()) {
                mySqlGroupBy.addItem(sqlExpr);
            }
            mySqlGroupBy.setRollUp(true);

            groupBy = mySqlGroupBy;
        }
    }

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

        if (groupBy == null) {
            groupBy = new SQLSelectGroupByClause();
        }
        groupBy.setHaving(this.exprParser.expr());
    }

    queryBlock.setGroupBy(groupBy);
}