Examples with MySqlUnique com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique used on opensource projects

Example 1 with MySqlUnique

use of com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique in project druid by alibaba.

the class SQLCreateTableStatement method isUNI.

/**
 * only for show columns
 */
public boolean isUNI(String columnName) {
    for (SQLTableElement element : this.tableElementList) {
        if (element instanceof MySqlUnique) {
            MySqlUnique unique = (MySqlUnique) element;
            if (unique.getColumns().size() == 0) {
                continue;
            }
            SQLExpr column = unique.getColumns().get(0).getExpr();
            if (column instanceof SQLIdentifierExpr && SQLUtils.nameEquals(columnName, ((SQLIdentifierExpr) column).getName())) {
                return unique.getColumns().size() == 1;
            } else if (column instanceof SQLMethodInvokeExpr && SQLUtils.nameEquals(((SQLMethodInvokeExpr) column).getMethodName(), columnName)) {
                return true;
            }
        }
    }
    return false;
}

Example 2 with MySqlUnique

use of com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique in project druid by alibaba.

the class SQLCreateTableStatement method isMUL.

/**
 * only for show columns
 */
public boolean isMUL(String columnName) {
    for (SQLTableElement element : this.tableElementList) {
        if (element instanceof MySqlUnique) {
            MySqlUnique unique = (MySqlUnique) element;
            SQLExpr column = unique.getColumns().get(0).getExpr();
            if (column instanceof SQLIdentifierExpr && SQLUtils.nameEquals(columnName, ((SQLIdentifierExpr) column).getName())) {
                return unique.getColumns().size() > 1;
            } else if (column instanceof SQLMethodInvokeExpr && SQLUtils.nameEquals(((SQLMethodInvokeExpr) column).getMethodName(), columnName)) {
                return true;
            }
        } else if (element instanceof MySqlKey) {
            MySqlKey unique = (MySqlKey) element;
            SQLExpr column = unique.getColumns().get(0).getExpr();
            if (column instanceof SQLIdentifierExpr && SQLUtils.nameEquals(columnName, ((SQLIdentifierExpr) column).getName())) {
                return true;
            } else if (column instanceof SQLMethodInvokeExpr && SQLUtils.nameEquals(((SQLMethodInvokeExpr) column).getMethodName(), columnName)) {
                return true;
            }
        }
    }
    return false;
}

Example 3 with MySqlUnique

use of com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique in project druid by alibaba.

the class MySqlCreateTableParser method parseConstraint.

protected SQLTableConstraint parseConstraint() {
    SQLName name = null;
    boolean hasConstaint = false;
    if (lexer.token() == (Token.CONSTRAINT)) {
        hasConstaint = true;
        lexer.nextToken();
    }
    if (lexer.token() == Token.IDENTIFIER) {
        name = this.exprParser.name();
    }
    SQLTableConstraint constraint = null;
    if (lexer.token() == (Token.KEY)) {
        MySqlKey key = new MySqlKey();
        this.exprParser.parseIndex(key.getIndexDefinition());
        key.setHasConstraint(hasConstaint);
        if (name != null) {
            key.setName(name);
        }
        constraint = key;
    } else if (lexer.token() == Token.PRIMARY) {
        MySqlPrimaryKey pk = this.getExprParser().parsePrimaryKey();
        if (name != null) {
            pk.setName(name);
        }
        pk.setHasConstraint(hasConstaint);
        constraint = pk;
    } else if (lexer.token() == Token.UNIQUE) {
        MySqlUnique uk = this.getExprParser().parseUnique();
        // should not use CONSTRAINT [symbol] for index name if index_name already specified
        if (name != null && uk.getName() == null) {
            uk.setName(name);
        }
        uk.setHasConstraint(hasConstaint);
        constraint = uk;
    } else if (lexer.token() == Token.FOREIGN) {
        MysqlForeignKey fk = this.getExprParser().parseForeignKey();
        fk.setName(name);
        fk.setHasConstraint(hasConstaint);
        constraint = fk;
    } else if (lexer.token() == Token.CHECK) {
        lexer.nextToken();
        SQLCheck check = new SQLCheck();
        check.setName(name);
        SQLExpr expr = this.exprParser.primary();
        check.setExpr(expr);
        constraint = check;
        boolean enforce = true;
        if (Token.NOT.equals(lexer.token())) {
            enforce = false;
            lexer.nextToken();
        }
        if (lexer.stringVal().equalsIgnoreCase("ENFORCED")) {
            check.setEnforced(enforce);
            lexer.nextToken();
        }
        if (lexer.token() == Token.HINT) {
            String hintText = lexer.stringVal();
            if (hintText != null) {
                hintText = hintText.trim();
            }
            if (hintText.startsWith("!")) {
                if (hintText.endsWith("NOT ENFORCED")) {
                    check.setEnforced(false);
                } else if (hintText.endsWith(" ENFORCED")) {
                    check.setEnforced(true);
                }
                lexer.nextToken();
            }
        }
    }
    if (constraint != null) {
        if (lexer.token() == Token.COMMENT) {
            lexer.nextToken();
            SQLExpr comment = this.exprParser.primary();
            constraint.setComment(comment);
        }
        return constraint;
    }
    throw new ParserException("TODO. " + lexer.info());
}

Example 4 with MySqlUnique

use of com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique in project druid by alibaba.

the class MySqlCreateTableParser method parseCreateTable.

public MySqlCreateTableStatement parseCreateTable(boolean acceptCreate) {
    MySqlCreateTableStatement stmt = new MySqlCreateTableStatement();
    if (acceptCreate) {
        if (lexer.hasComment() && lexer.isKeepComments()) {
            stmt.addBeforeComment(lexer.readAndResetComments());
        }
        accept(Token.CREATE);
    }
    if (lexer.identifierEquals("TEMPORARY")) {
        lexer.nextToken();
        stmt.setType(SQLCreateTableStatement.Type.GLOBAL_TEMPORARY);
    } else if (lexer.identifierEquals("SHADOW")) {
        lexer.nextToken();
        stmt.setType(SQLCreateTableStatement.Type.SHADOW);
    }
    if (lexer.identifierEquals(FnvHash.Constants.DIMENSION)) {
        lexer.nextToken();
        stmt.setDimension(true);
    }
    if (lexer.token() == Token.HINT) {
        this.exprParser.parseHints(stmt.getHints());
    }
    if (lexer.identifierEquals(FnvHash.Constants.EXTERNAL)) {
        lexer.nextToken();
        stmt.setExternal(true);
    }
    accept(Token.TABLE);
    if (lexer.token() == Token.IF || lexer.identifierEquals("IF")) {
        lexer.nextToken();
        accept(Token.NOT);
        accept(Token.EXISTS);
        stmt.setIfNotExiists(true);
    }
    stmt.setName(this.exprParser.name());
    if (lexer.token() == Token.LIKE) {
        lexer.nextToken();
        SQLName name = this.exprParser.name();
        stmt.setLike(name);
    }
    if (lexer.token() == Token.WITH) {
        SQLSelect query = new MySqlSelectParser(this.exprParser).select();
        stmt.setSelect(query);
    } else if (lexer.token() == (Token.LPAREN)) {
        lexer.nextToken();
        if (lexer.token() == Token.SELECT) {
            SQLSelect query = new MySqlSelectParser(this.exprParser).select();
            stmt.setSelect(query);
        } else {
            for (; ; ) {
                SQLColumnDefinition column = null;
                boolean global = false;
                if (lexer.identifierEquals(FnvHash.Constants.GLOBAL)) {
                    final Lexer.SavePoint mark = lexer.mark();
                    lexer.nextToken();
                    if (lexer.token() == Token.INDEX || lexer.token() == Token.UNIQUE) {
                        global = true;
                    } else {
                        lexer.reset(mark);
                    }
                }
                if (lexer.token() == Token.FULLTEXT) {
                    Lexer.SavePoint mark = lexer.mark();
                    lexer.nextToken();
                    if (lexer.token() == Token.KEY) {
                        MySqlKey fulltextKey = new MySqlKey();
                        this.exprParser.parseIndex(fulltextKey.getIndexDefinition());
                        fulltextKey.setIndexType("FULLTEXT");
                        fulltextKey.setParent(stmt);
                        stmt.getTableElementList().add(fulltextKey);
                        while (lexer.token() == Token.HINT) {
                            lexer.nextToken();
                        }
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else if (lexer.token() == Token.INDEX) {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("FULLTEXT");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else if (lexer.token() == Token.IDENTIFIER && MySqlUtils.isBuiltinDataType(lexer.stringVal())) {
                        lexer.reset(mark);
                    } else {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("FULLTEXT");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    }
                } else if (lexer.identifierEquals(FnvHash.Constants.SPATIAL)) {
                    Lexer.SavePoint mark = lexer.mark();
                    lexer.nextToken();
                    if (lexer.token() == Token.INDEX || lexer.token() == Token.KEY || lexer.token() != Token.IDENTIFIER || !MySqlUtils.isBuiltinDataType(lexer.stringVal())) {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("SPATIAL");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else {
                        lexer.reset(mark);
                    }
                }
                if (lexer.identifierEquals(FnvHash.Constants.ANN)) {
                    Lexer.SavePoint mark = lexer.mark();
                    lexer.nextToken();
                    if (lexer.token() == Token.INDEX || lexer.token() == Token.KEY) {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("ANN");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else {
                        lexer.reset(mark);
                    }
                }
                if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) {
                    lexer.nextToken();
                    if (lexer.token() == Token.KEY) {
                        MySqlKey clsKey = new MySqlKey();
                        this.exprParser.parseIndex(clsKey.getIndexDefinition());
                        clsKey.setIndexType("CLUSTERED");
                        clsKey.setParent(stmt);
                        stmt.getTableElementList().add(clsKey);
                        if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else if (lexer.token() == Token.INDEX) {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("CLUSTERED");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    }
                } else if (lexer.identifierEquals(FnvHash.Constants.CLUSTERING)) {
                    lexer.nextToken();
                    if (lexer.token() == Token.KEY) {
                        MySqlKey clsKey = new MySqlKey();
                        this.exprParser.parseIndex(clsKey.getIndexDefinition());
                        clsKey.setIndexType("CLUSTERING");
                        clsKey.setParent(stmt);
                        stmt.getTableElementList().add(clsKey);
                        if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    } else if (lexer.token() == Token.INDEX) {
                        MySqlTableIndex idx = new MySqlTableIndex();
                        this.exprParser.parseIndex(idx.getIndexDefinition());
                        idx.setIndexType("CLUSTERING");
                        idx.setParent(stmt);
                        stmt.getTableElementList().add(idx);
                        if (lexer.token() == Token.RPAREN) {
                            break;
                        } else if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                    }
                } else if (// 
                lexer.token() == Token.IDENTIFIER || lexer.token() == Token.LITERAL_CHARS) {
                    column = this.exprParser.parseColumn();
                    column.setParent(stmt);
                    stmt.getTableElementList().add(column);
                    if (lexer.isKeepComments() && lexer.hasComment()) {
                        column.addAfterComment(lexer.readAndResetComments());
                    }
                } else if (// 
                lexer.token() == Token.CONSTRAINT || // 
                lexer.token() == Token.PRIMARY || lexer.token() == Token.UNIQUE) {
                    SQLTableConstraint constraint = this.parseConstraint();
                    constraint.setParent(stmt);
                    if (constraint instanceof MySqlUnique) {
                        MySqlUnique unique = (MySqlUnique) constraint;
                        if (global) {
                            unique.setGlobal(true);
                        }
                    }
                    stmt.getTableElementList().add(constraint);
                } else if (lexer.token() == (Token.INDEX)) {
                    MySqlTableIndex idx = new MySqlTableIndex();
                    this.exprParser.parseIndex(idx.getIndexDefinition());
                    if (global) {
                        idx.getIndexDefinition().setGlobal(true);
                    }
                    idx.setParent(stmt);
                    stmt.getTableElementList().add(idx);
                } else if (lexer.token() == (Token.KEY)) {
                    Lexer.SavePoint savePoint = lexer.mark();
                    lexer.nextToken();
                    boolean isColumn = false;
                    if (lexer.identifierEquals(FnvHash.Constants.VARCHAR)) {
                        isColumn = true;
                    }
                    lexer.reset(savePoint);
                    if (isColumn) {
                        column = this.exprParser.parseColumn();
                        stmt.getTableElementList().add(column);
                    } else {
                        stmt.getTableElementList().add(parseConstraint());
                    }
                } else if (lexer.token() == (Token.PRIMARY)) {
                    SQLTableConstraint pk = parseConstraint();
                    pk.setParent(stmt);
                    stmt.getTableElementList().add(pk);
                } else if (lexer.token() == (Token.FOREIGN)) {
                    SQLForeignKeyConstraint fk = this.getExprParser().parseForeignKey();
                    fk.setParent(stmt);
                    stmt.getTableElementList().add(fk);
                } else if (lexer.token() == Token.CHECK) {
                    SQLCheck check = this.exprParser.parseCheck();
                    stmt.getTableElementList().add(check);
                } else if (lexer.token() == Token.LIKE) {
                    lexer.nextToken();
                    SQLTableLike tableLike = new SQLTableLike();
                    tableLike.setTable(new SQLExprTableSource(this.exprParser.name()));
                    tableLike.setParent(stmt);
                    stmt.getTableElementList().add(tableLike);
                    if (lexer.identifierEquals(FnvHash.Constants.INCLUDING)) {
                        lexer.nextToken();
                        acceptIdentifier("PROPERTIES");
                        tableLike.setIncludeProperties(true);
                    } else if (lexer.identifierEquals(FnvHash.Constants.EXCLUDING)) {
                        lexer.nextToken();
                        acceptIdentifier("PROPERTIES");
                        tableLike.setExcludeProperties(true);
                    }
                } else {
                    column = this.exprParser.parseColumn();
                    stmt.getTableElementList().add(column);
                }
                if (lexer.token() == Token.HINT) {
                    lexer.nextToken();
                }
                if (lexer.token() != Token.COMMA) {
                    break;
                } else {
                    lexer.nextToken();
                    if (lexer.isKeepComments() && lexer.hasComment() && column != null) {
                        column.addAfterComment(lexer.readAndResetComments());
                    }
                }
            }
        }
        if (lexer.token() == Token.HINT) {
            lexer.nextToken();
        }
        accept(Token.RPAREN);
        if (lexer.token() == Token.HINT && lexer.stringVal().charAt(0) == '!') {
            lexer.nextToken();
        }
    }
    for (; ; ) {
        if (lexer.token() == Token.COMMA) {
            lexer.nextToken();
        }
        if (lexer.identifierEquals(FnvHash.Constants.ENGINE)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = null;
            if (lexer.token() == Token.MERGE) {
                expr = new SQLIdentifierExpr(lexer.stringVal());
                lexer.nextToken();
            } else {
                expr = this.exprParser.expr();
            }
            stmt.setEngine(expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.BLOCK_SIZE)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = null;
            if (lexer.token() == Token.MERGE) {
                expr = new SQLIdentifierExpr(lexer.stringVal());
                lexer.nextToken();
            } else {
                expr = this.exprParser.integerExpr();
            }
            stmt.addOption("BLOCK_SIZE", expr);
            continue;
        }
        if (lexer.identifierEquals("BLOCK_FORMAT")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = this.exprParser.primary();
            stmt.addOption("BLOCK_FORMAT", expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.REPLICA_NUM)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = this.exprParser.integerExpr();
            stmt.addOption("REPLICA_NUM", expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.TABLET_SIZE)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = this.exprParser.integerExpr();
            stmt.addOption("TABLET_SIZE", expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.PCTFREE)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = this.exprParser.integerExpr();
            stmt.addOption("PCTFREE", expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.USE_BLOOM_FILTER)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            SQLExpr expr = this.exprParser.primary();
            stmt.addOption("USE_BLOOM_FILTER", expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.AUTO_INCREMENT)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("AUTO_INCREMENT", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("AVG_ROW_LENGTH")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("AVG_ROW_LENGTH", this.exprParser.expr());
            continue;
        }
        if (lexer.token() == Token.DEFAULT) {
            lexer.nextToken();
            parseTableOptionCharsetOrCollate(stmt);
            continue;
        }
        if (parseTableOptionCharsetOrCollate(stmt)) {
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.CHECKSUM)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("CHECKSUM", this.exprParser.expr());
            continue;
        }
        if (lexer.token() == Token.COMMENT) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.setComment(this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.CONNECTION)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("CONNECTION", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.DATA)) {
            lexer.nextToken();
            acceptIdentifier("DIRECTORY");
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("DATA DIRECTORY", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("DELAY_KEY_WRITE")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("DELAY_KEY_WRITE", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("FULLTEXT_DICT")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("FULLTEXT_DICT", this.exprParser.charExpr());
            continue;
        }
        if (lexer.token() == Token.INDEX) {
            lexer.nextToken();
            acceptIdentifier("DIRECTORY");
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("INDEX DIRECTORY", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("INSERT_METHOD")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("INSERT_METHOD", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("KEY_BLOCK_SIZE")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("KEY_BLOCK_SIZE", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.MAX_ROWS)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("MAX_ROWS", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.MIN_ROWS)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("MIN_ROWS", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.PACK_KEYS)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("PACK_KEYS", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.PASSWORD)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("PASSWORD", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("ROW_FORMAT")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("ROW_FORMAT", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("STATS_AUTO_RECALC")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("STATS_AUTO_RECALC", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("STATS_PERSISTENT")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("STATS_PERSISTENT", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("STATS_SAMPLE_PAGES")) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("STATS_SAMPLE_PAGES", this.exprParser.expr());
            continue;
        }
        if (lexer.token() == Token.UNION) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            accept(Token.LPAREN);
            SQLListExpr list = new SQLListExpr();
            this.exprParser.exprList(list.getItems(), list);
            stmt.addOption("UNION", list);
            accept(Token.RPAREN);
            continue;
        }
        if (lexer.token() == Token.TABLESPACE) {
            lexer.nextToken();
            TableSpaceOption option = new TableSpaceOption();
            option.setName(this.exprParser.name());
            if (lexer.identifierEquals("STORAGE")) {
                lexer.nextToken();
                option.setStorage(this.exprParser.name());
            }
            stmt.addOption("TABLESPACE", option);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.TABLEGROUP)) {
            lexer.nextToken();
            SQLName tableGroup = this.exprParser.name();
            stmt.setTableGroup(tableGroup);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.TYPE)) {
            lexer.nextToken();
            accept(Token.EQ);
            stmt.addOption("TYPE", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals("INDEX_ALL")) {
            lexer.nextToken();
            accept(Token.EQ);
            if (lexer.token() == Token.LITERAL_CHARS) {
                if ("Y".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();
                    stmt.addOption("INDEX_ALL", new SQLCharExpr("Y"));
                } else if ("N".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();
                    stmt.addOption("INDEX_ALL", new SQLCharExpr("N"));
                } else {
                    throw new ParserException("INDEX_ALL accept parameter ['Y' or 'N'] only.");
                }
            }
            continue;
        }
        if (lexer.identifierEquals("RT_INDEX_ALL")) {
            lexer.nextToken();
            accept(Token.EQ);
            if (lexer.token() == Token.LITERAL_CHARS) {
                if ("Y".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();
                    stmt.addOption("RT_INDEX_ALL", new SQLCharExpr("Y"));
                } else if ("N".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();
                    stmt.addOption("RT_INDEX_ALL", new SQLCharExpr("N"));
                } else {
                    throw new ParserException("RT_INDEX_ALL accepts parameter ['Y' or 'N'] only.");
                }
            }
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.ARCHIVE)) {
            lexer.nextToken();
            accept(Token.BY);
            acceptIdentifier("OSS");
            stmt.setArchiveBy(new SQLIdentifierExpr("OSS"));
            continue;
        }
        if (lexer.identifierEquals("STORAGE_TYPE")) {
            lexer.nextToken();
            accept(Token.EQ);
            stmt.addOption("STORAGE_TYPE", this.exprParser.charExpr());
            continue;
        }
        if (lexer.identifierEquals("STORAGE_POLICY")) {
            lexer.nextToken();
            accept(Token.EQ);
            stmt.addOption("STORAGE_POLICY", this.exprParser.charExpr());
            continue;
        }
        if (lexer.identifierEquals("HOT_PARTITION_COUNT")) {
            lexer.nextToken();
            accept(Token.EQ);
            try {
                stmt.addOption("HOT_PARTITION_COUNT", this.exprParser.integerExpr());
            } catch (Exception e) {
                throw new ParserException("only integer number is supported for hot_partition_count");
            }
            continue;
        }
        if (lexer.identifierEquals("TABLE_PROPERTIES")) {
            lexer.nextToken();
            accept(Token.EQ);
            stmt.addOption("TABLE_PROPERTIES", exprParser.charExpr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.ENCRYPTION)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("ENCRYPTION", this.exprParser.expr());
            continue;
        } else if (lexer.identifierEquals(FnvHash.Constants.COMPRESSION)) {
            lexer.nextToken();
            if (lexer.token() == Token.EQ) {
                lexer.nextToken();
            }
            stmt.addOption("COMPRESSION", this.exprParser.expr());
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) {
            lexer.nextToken();
            accept(Token.BY);
            accept(Token.LPAREN);
            for (; ; ) {
                SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem();
                stmt.addClusteredByItem(item);
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                }
                break;
            }
            accept(Token.RPAREN);
            continue;
        }
        if (lexer.token() == Token.PARTITION) {
            SQLPartitionBy partitionClause = parsePartitionBy();
            stmt.setPartitioning(partitionClause);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.BROADCAST)) {
            lexer.nextToken();
            stmt.setBroadCast(true);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.DISTRIBUTE) || lexer.identifierEquals(FnvHash.Constants.DISTRIBUTED)) {
            lexer.nextToken();
            accept(Token.BY);
            if (lexer.identifierEquals(FnvHash.Constants.HASH)) {
                lexer.nextToken();
                accept(Token.LPAREN);
                for (; ; ) {
                    SQLName name = this.exprParser.name();
                    stmt.getDistributeBy().add(name);
                    if (lexer.token() == Token.COMMA) {
                        lexer.nextToken();
                        continue;
                    }
                    break;
                }
                accept(Token.RPAREN);
                stmt.setDistributeByType(new SQLIdentifierExpr("HASH"));
            } else if (lexer.identifierEquals(FnvHash.Constants.BROADCAST)) {
                lexer.nextToken();
                stmt.setDistributeByType(new SQLIdentifierExpr("BROADCAST"));
            }
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.DBPARTITION)) {
            lexer.nextToken();
            accept(Token.BY);
            SQLExpr dbPartitoinBy = this.exprParser.primary();
            stmt.setDbPartitionBy(dbPartitoinBy);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.DBPARTITIONS)) {
            lexer.nextToken();
            SQLExpr dbPartitions = this.exprParser.primary();
            stmt.setDbPartitions(dbPartitions);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.TBPARTITION)) {
            lexer.nextToken();
            accept(Token.BY);
            SQLExpr expr = this.exprParser.expr();
            if (lexer.identifierEquals(FnvHash.Constants.STARTWITH)) {
                lexer.nextToken();
                SQLExpr start = this.exprParser.primary();
                acceptIdentifier("ENDWITH");
                SQLExpr end = this.exprParser.primary();
                expr = new SQLBetweenExpr(expr, start, end);
            }
            stmt.setTablePartitionBy(expr);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.TBPARTITIONS)) {
            lexer.nextToken();
            SQLExpr tbPartitions = this.exprParser.primary();
            stmt.setTablePartitions(tbPartitions);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.EXTPARTITION)) {
            lexer.nextToken();
            accept(Token.LPAREN);
            MySqlExtPartition partitionDef = new MySqlExtPartition();
            for (; ; ) {
                MySqlExtPartition.Item item = new MySqlExtPartition.Item();
                if (lexer.identifierEquals(FnvHash.Constants.DBPARTITION)) {
                    lexer.nextToken();
                    SQLName name = this.exprParser.name();
                    item.setDbPartition(name);
                    accept(Token.BY);
                    SQLExpr value = this.exprParser.primary();
                    item.setDbPartitionBy(value);
                }
                if (lexer.identifierEquals(FnvHash.Constants.TBPARTITION)) {
                    lexer.nextToken();
                    SQLName name = this.exprParser.name();
                    item.setTbPartition(name);
                    accept(Token.BY);
                    SQLExpr value = this.exprParser.primary();
                    item.setTbPartitionBy(value);
                }
                item.setParent(partitionDef);
                partitionDef.getItems().add(item);
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                } else {
                    break;
                }
            }
            accept(Token.RPAREN);
            stmt.setExPartition(partitionDef);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.OPTIONS)) {
            lexer.nextToken();
            accept(Token.LPAREN);
            stmt.putAttribute("ads.options", Boolean.TRUE);
            for (; ; ) {
                String name = lexer.stringVal();
                lexer.nextToken();
                accept(Token.EQ);
                SQLExpr value = this.exprParser.primary();
                stmt.addOption(name, value);
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                }
                break;
            }
            accept(Token.RPAREN);
            continue;
        }
        if (lexer.identifierEquals(FnvHash.Constants.STORED)) {
            lexer.nextToken();
            accept(Token.BY);
            SQLName name = this.exprParser.name();
            stmt.setStoredBy(name);
        }
        if (lexer.token() == Token.WITH) {
            lexer.nextToken();
            accept(Token.LPAREN);
            for (; ; ) {
                String name = lexer.stringVal();
                lexer.nextToken();
                accept(Token.EQ);
                SQLName value = this.exprParser.name();
                stmt.getWith().put(name, value);
                if (lexer.token() == Token.COMMA) {
                    lexer.nextToken();
                    continue;
                }
                break;
            }
            accept(Token.RPAREN);
            continue;
        }
        if (lexer.token() == (Token.HINT)) {
            this.exprParser.parseHints(stmt.getOptionHints());
            continue;
        }
        break;
    }
    if (lexer.token() == (Token.ON)) {
        throw new ParserException("TODO. " + lexer.info());
    }
    if (lexer.token() == Token.REPLACE) {
        lexer.nextToken();
        stmt.setReplace(true);
    } else if (lexer.identifierEquals("IGNORE")) {
        lexer.nextToken();
        stmt.setIgnore(true);
    }
    if (lexer.token() == (Token.AS)) {
        lexer.nextToken();
        if (lexer.token() == Token.LPAREN) {
            lexer.nextToken();
            SQLSelect query = new MySqlSelectParser(this.exprParser).select();
            stmt.setSelect(query);
            accept(Token.RPAREN);
        }
    }
    SQLCommentHint hint = null;
    if (lexer.token() == Token.HINT) {
        hint = this.exprParser.parseHint();
    }
    if (lexer.token() == (Token.SELECT)) {
        SQLSelect query = new MySqlSelectParser(this.exprParser).select();
        if (hint != null) {
            query.setHeadHint(hint);
        }
        stmt.setSelect(query);
        if (lexer.token() == Token.WITH) {
            lexer.nextToken();
            if (lexer.identifierEquals(FnvHash.Constants.NO)) {
                lexer.nextToken();
                acceptIdentifier("DATA");
                stmt.setWithData(false);
            } else {
                acceptIdentifier("DATA");
                stmt.setWithData(true);
            }
        }
    }
    while (lexer.token() == (Token.HINT)) {
        this.exprParser.parseHints(stmt.getOptionHints());
    }
    return stmt;
}

Example 5 with MySqlUnique

use of com.alibaba.druid.sql.dialect.mysql.ast.MySqlUnique in project druid by alibaba.

the class MySqlShowColumnOutpuVisitor method visit.

public boolean visit(MySqlCreateTableStatement x) {
    List<SQLColumnDefinition> columns = new ArrayList<SQLColumnDefinition>();
    List<String> dataTypes = new ArrayList<String>();
    List<String> defaultValues = new ArrayList<String>();
    int name_len = -1, dataType_len = -1, defaultVal_len = 7, extra_len = 5;
    for (SQLTableElement element : x.getTableElementList()) {
        if (element instanceof SQLColumnDefinition) {
            SQLColumnDefinition column = (SQLColumnDefinition) element;
            columns.add(column);
            String name = SQLUtils.normalize(column.getName().getSimpleName());
            if (name_len < name.length()) {
                name_len = name.length();
            }
            String dataType = column.getDataType().getName();
            if (column.getDataType().getArguments().size() > 0) {
                dataType += "(";
                for (int i = 0; i < column.getDataType().getArguments().size(); i++) {
                    if (i != 0) {
                        dataType += ",";
                    }
                    SQLExpr arg = column.getDataType().getArguments().get(i);
                    dataType += arg.toString();
                }
                dataType += ")";
            }
            if (dataType_len < dataType.length()) {
                dataType_len = dataType.length();
            }
            dataTypes.add(dataType);
            if (column.getDefaultExpr() == null) {
                defaultValues.add(null);
            } else {
                String defaultVal = SQLUtils.toMySqlString(column.getDefaultExpr());
                if (defaultVal.length() > 2 && defaultVal.charAt(0) == '\'' && defaultVal.charAt(defaultVal.length() - 1) == '\'') {
                    defaultVal = defaultVal.substring(1, defaultVal.length() - 1);
                }
                defaultValues.add(defaultVal);
                if (defaultVal_len < defaultVal.length()) {
                    defaultVal_len = defaultVal.length();
                }
            }
            if (column.isAutoIncrement()) {
                extra_len = "auto_increment".length();
            } else if (column.getOnUpdate() != null) {
                extra_len = "on update CURRENT_TIMESTAMP".length();
            }
        }
    }
    print("+-");
    print('-', name_len);
    print("-+-");
    print('-', dataType_len);
    print("-+------+-----+-");
    print('-', defaultVal_len);
    print("-+-");
    print('-', extra_len);
    print("-+\n");
    print("| ");
    print("Field", name_len, ' ');
    print(" | ");
    print("Type", dataType_len, ' ');
    print(" | Null | Key | ");
    print("Default", defaultVal_len, ' ');
    print(" | ");
    print("Extra", extra_len, ' ');
    print(" |\n");
    print("+-");
    print('-', name_len);
    print("-+-");
    print('-', dataType_len);
    print("-+------+-----+-");
    print('-', defaultVal_len);
    print("-+-");
    print('-', extra_len);
    print("-+\n");
    for (int i = 0; i < columns.size(); i++) {
        SQLColumnDefinition column = columns.get(i);
        String name = SQLUtils.normalize(column.getName().getSimpleName());
        print("| ");
        print(name, name_len, ' ');
        print(" | ");
        print(dataTypes.get(i), dataType_len, ' ');
        print(" | ");
        if (column.containsNotNullConstaint()) {
            print("NO ");
        } else {
            print("YES");
        }
        print("  | ");
        MySqlUnique unique = null;
        if (x.isPrimaryColumn(name)) {
            print("PRI");
        } else if (x.isUNI(name)) {
            print("UNI");
        } else if (x.isMUL(name)) {
            print("MUL");
        } else {
            print("   ");
        }
        print(" | ");
        String defaultVal = defaultValues.get(i);
        if (defaultVal == null) {
            print("NULL", defaultVal_len, ' ');
        } else {
            print(defaultVal, defaultVal_len, ' ');
        }
        print(" | ");
        if (column.isAutoIncrement()) {
            print("auto_increment", extra_len, ' ');
        } else if (column.getOnUpdate() != null) {
            print("on update CURRENT_TIMESTAMP", extra_len, ' ');
        } else {
            print(' ', extra_len);
        }
        print(" |");
        print("\n");
    }
    print("+-");
    print('-', name_len);
    print("-+-");
    print('-', dataType_len);
    print("-+------+-----+-");
    print('-', defaultVal_len);
    print("-+-");
    print('-', extra_len);
    print("-+\n");
    return false;
}