protected String as()

in core/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java [449:640]
178 lines of code
101 McCabe index (conditional complexity)

    protected String as() {
        String alias = null;

        final Token token = lexer.token;

        if (token == Token.COMMA) {
            return null;
        }

        if (token == Token.AS) {
            lexer.nextTokenAlias();
            if (lexer.token == Token.LPAREN) {
                return null;
            }

            // for oracle
            if (dialectFeatureEnabled(AsCommaFrom) && (lexer.token == Token.COMMA || lexer.token == Token.FROM)) {
                return null;
            }

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

            if (alias != null) {
                while (lexer.token == Token.DOT) {
                    lexer.nextToken();
                    alias += ('.' + lexer.token.name());
                    lexer.nextToken();
                }

                return alias;
            }

            if (lexer.token == Token.LPAREN) {
                return null;
            }

            throw new ParserException("Error : " + lexer.info());
        }

        if (lexer.token == Token.LITERAL_ALIAS) {
            alias = lexer.stringVal();
            lexer.nextToken();
        } else if (lexer.token == Token.IDENTIFIER) {
            alias = lexer.stringVal();
            boolean skip = false;
            if (dialectFeatureEnabled(AsSkip)) {
                skip = "TBLPROPERTIES".equalsIgnoreCase(alias);
            }
            if (skip) {
                alias = null;
            } else {
                lexer.nextToken();
            }
        } else if (lexer.token == Token.LITERAL_CHARS) {
            alias = "'" + lexer.stringVal() + "'";
            lexer.nextToken();
        } else {
            switch (lexer.token) {
                case CASE:
                case USER:
                case LOB:
                case END:
                case DEFERRED:
                case OUTER:
                case DO:
                case LOOP:
                case STORE:
                case MOD:
                case ANY:
                case BEGIN:
                case CAST:
                case COMPUTE:
                case ESCAPE:
                case FULL:
                case MERGE:
                case OPEN:
                case SOME:
                case TRUNCATE:
                case UNTIL:
                case VIEW:
                case KILL:
                case COMMENT:
                case TABLESPACE:
                case REPEAT:
                case PRIMARY:
                case FOREIGN:
                case UNIQUE:
                case LEAVE:
                case ENABLE:
                case DISABLE:
                case REPLACE:
                    alias = lexer.stringVal();
                    lexer.nextToken();
                    break;
                case INTERSECT:
                case EXCEPT:
                case DESC:
                case INOUT:
                case MINUS:
                case UPDATE:
                case DELETE:
                case TABLE:
                case UNION:
                case EXPLAIN:
                case CREATE:
                case LIMIT:
                case USE:
                case BY:
                case ALTER:
                case IN:
                case INTO:
                case ASC: {
                    alias = lexer.stringVal();

                    Lexer.SavePoint mark = lexer.mark();
                    lexer.nextToken();
                    if (lexer.token() != Token.COMMA
                            && lexer.token() != Token.RPAREN
                            && lexer.token() != Token.FROM
                            && lexer.token() != Token.SEMI
                            && lexer.token() != Token.SEMI
                    ) {
                        alias = null;
                        lexer.reset(mark);
                    }
                    break;
                }
                case CLOSE:
                case SEQUENCE:
                    if (dialectFeatureEnabled(AsSequence)) {
                        alias = lexer.stringVal();
                        lexer.nextToken();
                        break;
                    }
                    break;
                case CHECK:
                case INDEX:
                case ALL:
                case INNER:
                case VALUES:
                case SHOW:
                case TO:
                case REFERENCES:
                case LIKE:
                case RLIKE:
                case NULL:
                case RIGHT:
                case LEFT:
                case DATABASE:
                    if (dialectFeatureEnabled(AsDatabase)) {
                        alias = lexer.stringVal();
                        lexer.nextToken();
                        break;
                    }
                    break;
                case GROUP:
                case ORDER:
                case DISTRIBUTE:
                case DEFAULT:
                    if (dialectFeatureEnabled(AsDefault)) {
                        Lexer.SavePoint mark = lexer.mark();
                        alias = lexer.stringVal();
                        lexer.nextToken();
                        if (lexer.token == Token.BY) {
                            lexer.reset(mark);
                            alias = null;
                        }
                        break;
                    }
                    break;
                default:
                    break;
            }
        }

        switch (lexer.token) {
            case KEY:
            case INTERVAL:
            case CONSTRAINT:
                alias = lexer.token.name();
                lexer.nextToken();
                return alias;
            default:
                break;
        }

        if (isEnabled(SQLParserFeature.IgnoreNameQuotes) && alias != null && alias.length() > 1) {
            alias = StringUtils.removeNameQuotes(alias);
        }
        return alias;
    }