Method buildPlanForQueryNode

src/Planner/Planner.cpp:2093–2701

}

void Planner::buildPlanForQueryNode()
{
    ProfileEvents::increment(ProfileEvents::SelectQueriesWithSubqueries);
    ProfileEvents::increment(ProfileEvents::QueriesWithSubqueries);

    auto & query_node = query_tree->as<QueryNode &>();
    const auto & query_context = planner_context->getQueryContext();
    if (query_node.hasWhere())
    {
        auto condition_constant = tryExtractConstantFromConditionNode(query_node.getWhere());
        if (condition_constant.has_value() && *condition_constant)
            query_node.getWhere() = {};
    }

    SelectQueryInfo select_query_info = buildSelectQueryInfo();
    const Settings & settings = query_context->getSettingsRef();

    QueryResultCachePtr query_result_cache = planner_context->getMutableQueryContext()->getQueryResultCache();
    bool can_use_query_result_cache = query_context->getCanUseQueryResultCache();
    ASTPtr ast = select_query_info.query;

    /// Determine if the query result cache should be used for this query node (with `is_subquery = true` key).
    /// The Planner-level cache is separate from the `executeQuery`-level cache (`is_subquery = false`).
    /// Rules:
    /// 1. For actual subqueries: explicit SETTINGS `use_query_cache` on the node wins
    /// 2. `query_cache_for_subqueries` propagates from outer query (applies to all Planner invocations)
    /// 3. By default, `use_query_cache` does NOT propagate from outer query to subqueries
    bool should_cache = shouldUseQueryCacheForSubquery(query_node, can_use_query_result_cache, settings,
        select_query_options.is_subquery, query_context);

    /// Query result cache must actually exist
    if (should_cache && !query_result_cache)
        should_cache = false;

    /// For explicit per-subquery opt-in, we track cache eligibility locally
    /// without mutating the shared query context (which would leak to the outer query).
    bool local_can_use_cache = can_use_query_result_cache || should_cache;

    /// If the query runs with "use_query_cache = 1", we first probe if the query cache already contains the query result (if yes:
    /// return result from cache). If doesn't, we execute the query normally and write the result into the query cache. Both steps use a
    /// hash of the AST, the current database and the settings as cache key. Unfortunately, the settings are in some places internally
    /// modified between steps 1 and 2 (= during query execution) - this is silly but hard to forbid. As a result, the hashes no longer
    /// match and the cache is rendered ineffective. Therefore make a copy of the settings and use it for steps 1 and 2.
    std::optional<Settings> settings_copy;
    if (local_can_use_cache)
        settings_copy = settings;

    /// If it is a non-internal SELECT, and passive (read) use of the query cache is enabled, and the cache knows the query, then add a ReadFromQueryResultCacheStep instead of building the rest of the plan.
    if (should_cache && settings[Setting::enable_reads_from_query_cache])
    {
        QueryResultCache::Key key(ast, query_context->getCurrentDatabase(), *settings_copy, query_context->getCurrentQueryId(), query_context->getUserID(), query_context->getCurrentRoles(), /* is_subquery = */ true);
        auto reader = std::make_shared<QueryResultCacheReader>(query_result_cache->createReader(key));
        if (reader->hasCacheEntryForKey())
        {
            addReadFromQueryResultCacheStep(query_plan, reader->getSource(), reader->getSourceTotals(), reader->getSourceExtremes());
            return;
        }
    }