Function addBuildSubqueriesForSetsStepIfNeeded

src/Planner/Planner.cpp:1597–1662

}

void addBuildSubqueriesForSetsStepIfNeeded(
    QueryPlan & query_plan,
    const SelectQueryOptions & select_query_options,
    const PlannerContextPtr & planner_context,
    const UsefulSets & useful_sets)
{
    auto subqueries = planner_context->getPreparedSets().getSubqueries();

    auto predicate = [&useful_sets](const auto & set) { return !useful_sets.contains(set); };
    auto it = std::remove_if(subqueries.begin(), subqueries.end(), std::move(predicate));
    subqueries.erase(it, subqueries.end());

    for (auto & subquery : subqueries)
    {
        auto query_tree = subquery->detachQueryTree();
        auto subquery_options = select_query_options.subquery();
        /// Sets may use Materialized CTEs, so we need to materialize them in order to correctly build set from subquery.
        /// Normally CTEs are materialized before building sets and running the main query, but in case when
        /// set is built for primary key analysis, CTEs are not materialized yet.
        ///
        /// To build the set correctly, we need to add a DelayedMaterializingCTEsStep for CTEs in the set subquery plan.
        /// This is done by forceMaterializeCTE() method, which would lead collectMaterializedCTEs() to return non-empty result.
        ///
        /// As a result:
        /// 1. If set is built during primary key analysis FutureSetFromSubquery::buildSetInplace(), we will build plans for used CTEs materialization.
        ///    Later, when the main query plan is optimized, DelayedMaterializingCTEsStep for these CTEs will not add materialization plans again.
        /// 2. If set is built during main query execution, we will build plans for used CTEs materialization to be run before the set is built
        ///    and before the main query is executed.
        subquery_options.forceMaterializeCTE();
        /// I don't know if this is a good decision,
        /// but for now it is done in the same way as in old analyzer.
        /// This would not ignore limits for subqueries (affects mutations only).
        /// See test_build_sets_from_multiple_threads-analyzer.
        subquery_options.ignore_limits = false;
        Planner subquery_planner(
            query_tree,
            subquery_options,
            std::make_shared<GlobalPlannerContext>(
                nullptr, nullptr, nullptr, collectFiltersForAnalysis(query_tree, subquery_options, nullptr)));
        subquery_planner.buildQueryPlanIfNeeded();

        auto subquery_plan = std::move(subquery_planner).extractQueryPlan();
        /// Contexts should be copied into the root query plan, because some functions may
        /// be created using them while this subquery plan will be destroyed after
        /// FutureSetFromSubquery::buildSetInplace(). Otherwise, function execution may fail
        /// with a "Context has expired" exception.
        for (const auto & context : subquery_plan.getInterpretersContexts())
            query_plan.addInterpreterContext(context);
        subquery->setQueryPlan(std::make_unique<QueryPlan>(std::move(subquery_plan)));
    }

    if (!subqueries.empty())
    {
        const auto & settings = planner_context->getQueryContext()->getSettingsRef();
        SizeLimits network_transfer_limits(settings[Setting::max_rows_to_transfer], settings[Setting::max_bytes_to_transfer], settings[Setting::transfer_overflow_mode]);
        auto prepared_sets_cache = planner_context->getQueryContext()->getPreparedSetsCache();

        auto step = std::make_unique<DelayedCreatingSetsStep>(