Method parseImpl

src/Parsers/ParserTablesInSelectQuery.cpp:27–146

bool ParserTableExpression::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
    auto res = make_intrusive<ASTTableExpression>();

    if (!ParserWithOptionalAlias(std::make_unique<ParserSubquery>(), allow_alias_without_as_keyword).parse(pos, res->subquery, expected)
        && !ParserWithOptionalAlias(std::make_unique<ParserFunction>(false, true), allow_alias_without_as_keyword).parse(pos, res->table_function, expected)
        && !ParserWithOptionalAlias(std::make_unique<ParserCompoundIdentifier>(true, true), allow_alias_without_as_keyword)
                .parse(pos, res->database_and_table_name, expected)
        && !ParserWithOptionalAlias(std::make_unique<ParserTableAsStringLiteralIdentifier>(), allow_alias_without_as_keyword)
                .parse(pos, res->database_and_table_name, expected))
    {
        /// Parenthesized table join expression: (t1 JOIN t2 ON ...) → SELECT * FROM t1 JOIN t2 ON ...
        /// Standard SQL allows parentheses around joined table expressions in FROM clauses.
        if (pos->type == TokenType::OpeningRoundBracket)
        {
            auto open_paren = pos;
            ++pos;

            ASTPtr tables_in_select;
            if (ParserTablesInSelectQuery(false).parse(pos, tables_in_select, expected)
                && pos->type == TokenType::ClosingRoundBracket
                && tables_in_select->as<ASTTablesInSelectQuery &>().children.size() > 1)
            {
                ++pos;

                /// Build: SELECT * FROM <parsed_tables>
                auto select_ast = make_intrusive<ASTSelectQuery>();
                select_ast->setExpression(ASTSelectQuery::Expression::SELECT, make_intrusive<ASTExpressionList>());
                select_ast->select()->children.push_back(make_intrusive<ASTAsterisk>());
                select_ast->setExpression(ASTSelectQuery::Expression::TABLES, std::move(tables_in_select));

                auto list_of_selects = make_intrusive<ASTExpressionList>();
                list_of_selects->children.push_back(select_ast);

                auto select_with_union = make_intrusive<ASTSelectWithUnionQuery>();
                select_with_union->children.push_back(std::move(list_of_selects));
                select_with_union->list_of_selects = select_with_union->children.back();

                res->subquery = make_intrusive<ASTSubquery>(std::move(select_with_union));

                /// Parse optional alias: (t1 CROSS JOIN t2) AS j
                ParserAlias alias_parser(allow_alias_without_as_keyword);
                ASTPtr alias_node;
                if (alias_parser.parse(pos, alias_node, expected))
                    res->subquery->setAlias(alias_node->getColumnName());
            }
            else
            {
                pos = open_paren;
                return false;
            }
        }
        else
        {
            return false;
        }
    }