Function buildQueryPlanForCrossJoinNode

src/Planner/PlannerJoinTree.cpp:1694–1749

}

JoinTreeQueryPlan buildQueryPlanForCrossJoinNode(
    const QueryTreeNodePtr & join_table_expression,
    std::vector<JoinTreeQueryPlan> plans,
    const ColumnIdentifierSet & outer_scope_columns,
    PlannerContextPtr & planner_context)
{
    auto & cross_join_node = join_table_expression->as<CrossJoinNode &>();
    for (const auto & plan : plans)
    {
        if (plan.stage != QueryProcessingStage::FetchColumns)
            throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
                "JOIN {} table expression expected to process query to fetch columns stage. Actual {}",
                cross_join_node.formatASTForErrorMessage(),
                QueryProcessingStage::toString(plan.stage));
    }

    const auto & query_context = planner_context->getQueryContext();
    const auto & settings = query_context->getSettingsRef();

    const auto & table_expressions = cross_join_node.getTableExpressions();
    bool display_internal_aliases = settings[Setting::query_plan_display_internal_aliases];

    auto left_join_tree_query_plan = std::move(plans[0]);
    auto left_table_label = getQueryDisplayLabel(table_expressions.at(0), display_internal_aliases);

    for (size_t i = 1; i < plans.size(); ++i)
    {
        auto right_join_tree_query_plan = std::move(plans[i]);

        const auto & left_header = left_join_tree_query_plan.query_plan.getCurrentHeader();
        const auto & right_header = right_join_tree_query_plan.query_plan.getCurrentHeader();
        JoinExpressionActions join_expression_actions(*left_header, *right_header);
        auto join_step_logical = std::make_unique<JoinStepLogical>(
            left_header,
            right_header,
            JoinOperator{JoinKind::Cross},
            std::move(join_expression_actions),
            outer_scope_columns,
            std::unordered_map<String, const ActionsDAG::Node *>{},
            settings[Setting::join_use_nulls],
            JoinSettings(settings),
            SortingStep::Settings(settings));

        auto right_table_label = getQueryDisplayLabel(table_expressions.at(i), display_internal_aliases);
        join_step_logical->setInputLabels(std::move(left_table_label), std::move(right_table_label));
        left_table_label = join_step_logical->getReadableRelationName();

        appendSetsFromActionsDAG(join_step_logical->getActionsDAG(), left_join_tree_query_plan.useful_sets);
        left_join_tree_query_plan = joinPlansWithStep(
            std::move(join_step_logical),
            std::move(left_join_tree_query_plan),
            std::move(right_join_tree_query_plan));
    }

    return left_join_tree_query_plan;
}

void tryMakeDirectJoinWithMergeTree(const JoinOperator & join_operator,