public SQLStatement parseCreateDatabase()

in core/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java [7815:8033]
194 lines of code
55 McCabe index (conditional complexity)

    public SQLStatement parseCreateDatabase() {
        if (lexer.token() == Token.CREATE) {
            lexer.nextToken();
        }

        if (lexer.token() == Token.SCHEMA) {
            lexer.nextToken();
        } else {
            accept(Token.DATABASE);
        }

        SQLCreateDatabaseStatement stmt = new SQLCreateDatabaseStatement(dbType);

        if (lexer.token() == Token.HINT) {
            List<SQLCommentHint> hints = this.exprParser.parseHints();
            if (hints.size() == 1) {
                String text = hints.get(0).getText();
                if (text.charAt(0) == '!') {
                    String[] words = text.trim().split("\\s+");
                    if (words.length > 2
                            && words[words.length - 3].equalsIgnoreCase("IF")
                            && words[words.length - 2].equalsIgnoreCase("NOT")
                            && words[words.length - 1].equalsIgnoreCase("EXISTS")) {
                            stmt.setIfNotExists(true);
                    }
                }
            }
        }

        if (lexer.token() == Token.IF) {
            lexer.nextToken();
            accept(Token.NOT);
            accept(Token.EXISTS);
            stmt.setIfNotExists(true);
        }

        stmt.setName(this.exprParser.name());

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

        if (lexer.token() == Token.HINT) {
            List<SQLCommentHint> hints = this.exprParser.parseHints();
            if (hints.size() == 1) {
                String text = hints.get(0).getText();
                if (text.charAt(0) == '!') {
                    String[] words = text.trim().split("\\s+");
                    int idx = 0;
                    for (; idx < words.length; idx++) {
                        if (words[idx].equalsIgnoreCase("CHARACTER")
                                && idx < words.length - 2 && words[idx + 1].equalsIgnoreCase("SET")) {
                            stmt.setCharacterSet(words[idx + 2]);
                            idx += 2;
                        } else if (words[idx].equalsIgnoreCase("COLLATE")
                                && idx < words.length - 1) {
                            stmt.setCollate(words[idx + 1]);
                            idx += 1;
                        }
                    }
                }
            }
        }

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

        for (; ; ) {
            if (lexer.identifierEquals(FnvHash.Constants.CHARACTER)) {
                lexer.nextToken();
                accept(Token.SET);
                if (lexer.token() == Token.EQ) {
                    lexer.nextToken();
                }
                String charset = lexer.stringVal();
                accept(Token.IDENTIFIER);
                stmt.setCharacterSet(charset);
            } else if (lexer.identifierEquals(FnvHash.Constants.CHARSET)) {
                lexer.nextToken();
                if (lexer.token() == Token.EQ) {
                    lexer.nextToken();
                }
                String charset = lexer.stringVal();
                accept(Token.IDENTIFIER);
                stmt.setCharacterSet(charset);
            } else if (lexer.token() == Token.DEFAULT) {
                lexer.nextToken();
            } else if (lexer.identifierEquals(FnvHash.Constants.COLLATE)) {
                lexer.nextToken();
                if (lexer.token() == Token.EQ) {
                    lexer.nextToken();
                }
                String collate = lexer.stringVal();
                accept(Token.IDENTIFIER);
                stmt.setCollate(collate);
            } else if (lexer.identifierEquals(FnvHash.Constants.PASSWORD)) {
                lexer.nextToken();
                if (lexer.token() == Token.EQ) {
                    lexer.nextToken();
                }
                SQLExpr password = this.exprParser.primary();
                stmt.setPassword(password);
            }
            //ads 特殊支持
            else if (lexer.identifierEquals("SHARDS") || lexer.identifierEquals("SHARD_ID")
                    || lexer.identifierEquals("REPLICATION") || lexer.identifierEquals("STORAGE_DEPENDENCY")
                    || lexer.identifierEquals("REPLICA_TYPE") || lexer.identifierEquals("DATA_REPLICATION")) {
                String key = lexer.stringVal();
                lexer.nextToken();
                accept(Token.EQ);
                SQLExpr value = this.exprParser.expr();
                stmt.getOptions().put(key, value);
            } else {
                break;
            }
        }

        if (lexer.token() == Token.FOR) {
            lexer.nextToken();
            String user = lexer.stringVal();
            lexer.nextToken();
            stmt.setUser(user);
        }

        if (lexer.identifierEquals(FnvHash.Constants.OPTIONS)) {
            lexer.nextToken();
            accept(Token.LPAREN);
            for (; ; ) {
                if (lexer.token() == Token.RPAREN) {
                    accept(Token.RPAREN);
                    break;
                }
                String key = lexer.stringVal();
                lexer.nextToken();
                accept(Token.EQ);
                SQLExpr value = this.exprParser.expr();
                stmt.getOptions().put(key, value);
            }
        }

        if (lexer.token() == WITH) {
            lexer.nextToken();

            accept(Token.LPAREN);
            for (; ; ) {
                SQLAssignItem assignItem = this.exprParser.parseAssignItem();
                assignItem.setParent(stmt);
                stmt.getDbProperties().add(assignItem);

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

        if (lexer.identifierEquals(FnvHash.Constants.STORED)) {
            lexer.nextToken();

            if (lexer.token() == Token.BY) {
                accept(Token.BY);

                for (; ; ) {
                    List<SQLAssignItem> storedByItem = new ArrayList<SQLAssignItem>();
                    accept(Token.LPAREN);
                    for (; ; ) {
                        SQLAssignItem assignItem = this.exprParser.parseAssignItem();
                        assignItem.setParent(stmt);
                        storedByItem.add(assignItem);

                        if (lexer.token() == Token.COMMA) {
                            lexer.nextToken();
                            continue;
                        }
                        break;
                    }
                    accept(Token.RPAREN);
                    stmt.getStoredBy().add(storedByItem);

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

                    break;
                }
            } else if (lexer.token() == Token.IN) {
                lexer.nextToken();

                stmt.setStoredIn(this.exprParser.name());

                accept(Token.ON);
                accept(Token.LPAREN);
                for (; ; ) {
                    SQLAssignItem assignItem = this.exprParser.parseAssignItem();
                    assignItem.setParent(stmt);
                    stmt.getStoredOn().add(assignItem);

                    if (lexer.token() == Token.COMMA) {
                        lexer.nextToken();
                        continue;
                    }
                    break;
                }
                accept(Token.RPAREN);
            } else if (lexer.token() == Token.AS) {
                lexer.nextToken();
                SQLExpr like = this.exprParser.expr();
                stmt.setStoredAs(like);
            } else {
                throw new ParserException("TODO " + lexer.info());
            }
        }

        return stmt;
    }