Method initializeQueryJoinTreeNode

src/Analyzer/Resolve/QueryAnalyzer.cpp:4007–4178

Initialize query join tree node. * * 1. Resolve identifiers. * 2. Register table, table function, query, union, join, array join nodes in scope table expressions in resolve process. */

  * 2. Register table, table function, query, union, join, array join nodes in scope table expressions in resolve process.
  */
void QueryAnalyzer::initializeQueryJoinTreeNode(QueryTreeNodePtr & join_tree_node, IdentifierResolveScope & scope)
{
    std::deque<QueryTreeNodePtr *> join_tree_node_ptrs_to_process_queue;
    join_tree_node_ptrs_to_process_queue.push_back(&join_tree_node);

    while (!join_tree_node_ptrs_to_process_queue.empty())
    {
        auto * current_join_tree_node_ptr = join_tree_node_ptrs_to_process_queue.front();
        join_tree_node_ptrs_to_process_queue.pop_front();

        auto & current_join_tree_node = *current_join_tree_node_ptr;
        auto current_join_tree_node_type = current_join_tree_node->getNodeType();

        switch (current_join_tree_node_type)
        {
            case QueryTreeNodeType::IDENTIFIER:
            {
                auto & from_table_identifier = current_join_tree_node->as<IdentifierNode &>();
                auto table_identifier_lookup = IdentifierLookup{from_table_identifier.getIdentifier(), IdentifierLookupContext::TABLE_EXPRESSION};
                if (current_join_tree_node->hasOriginalAST())
                    table_identifier_lookup.original_ast_node = current_join_tree_node->getOriginalAST();

                auto from_table_identifier_alias = from_table_identifier.getAlias();

                IdentifierResolveContext resolve_settings;
                /// In join tree initialization ignore join tree as identifier lookup source
                resolve_settings.allow_to_check_join_tree = false;
                /** Disable resolve of subquery during identifier resolution.
                  * Example: SELECT * FROM (SELECT 1) AS t1, t1;
                  * During `t1` identifier resolution we resolve it into subquery SELECT 1, but we want to disable
                  * subquery resolution at this stage, because JOIN TREE of parent query is not resolved.
                  */
                resolve_settings.allow_to_resolve_subquery_during_identifier_resolution = false;

                scope.pushExpressionNode(current_join_tree_node);

                auto table_identifier_resolve_result = tryResolveIdentifier(table_identifier_lookup, scope, resolve_settings);

                scope.popExpressionNode();

                auto resolved_identifier = table_identifier_resolve_result.resolved_identifier;

                if (!resolved_identifier)
                {
                    /// Suggest a similar table name, possibly from another database (e.g.
                    /// `system.functions` for a bare `functions`), matching the old analyzer's hint.
                    auto [hint_database_name, hint_table_name]
                        = IdentifierResolver::tryGetTableNameHint(from_table_identifier.getIdentifier(), scope.context);
                    if (!hint_database_name.empty())
                        throw Exception(ErrorCodes::UNKNOWN_TABLE,
                            "Unknown table expression identifier '{}' in scope {}. Maybe you meant {}.{}?",
                            from_table_identifier.getIdentifier().getFullName(),
                            scope.scope_node->formatASTForErrorMessage(),
                            backQuoteIfNeed(hint_database_name),
                            backQuoteIfNeed(hint_table_name));
                    throw Exception(ErrorCodes::UNKNOWN_TABLE,
                        "Unknown table expression identifier '{}' in scope {}",
                        from_table_identifier.getIdentifier().getFullName(),