Method getQueryProcessingStage

src/Storages/StorageMerge.cpp:376–440

}

QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage(
    ContextPtr local_context,
    QueryProcessingStage::Enum to_stage,
    const StorageSnapshotPtr &,
    SelectQueryInfo & query_info) const
{
    /// In case of JOIN or ARRAY JOIN the first stage (which includes JOIN/ARRAY JOIN)
    /// should be done on the initiator always.
    ///
    /// Since in case of JOIN query on shards will receive query without JOIN (and their columns).
    /// (see removeJoin())
    ///
    /// ARRAY JOIN also requires FetchColumns because `buildQueryPlanForArrayJoinNode` expects
    /// the child plan to be at FetchColumns stage. If we return a later stage here,
    /// the ARRAY JOIN processing is skipped entirely in `buildJoinTreeQueryPlan`
    /// (see the early return when stage != FetchColumns), leading to missing chunk info
    /// in MergingAggregatedTransform.
    ///
    /// And for this we need to return FetchColumns.
    if (const auto * select = query_info.query->as<ASTSelectQuery>(); select && (hasJoin(*select) || hasArrayJoin(*select)))
        return QueryProcessingStage::FetchColumns;

    auto stage_in_source_tables = QueryProcessingStage::FetchColumns;

    DatabaseTablesIterators database_table_iterators = database_name_or_regexp.getDatabaseIterators(local_context);

    size_t selected_table_size = 0;

    for (const auto & iterator : database_table_iterators)
    {
        while (iterator->isValid())
        {
            const auto & table = iterator->table();
            if (table && table.get() != this)
            {
                ++selected_table_size;
                const auto table_metadata = table->getInMemoryMetadataPtr(local_context, false);
                stage_in_source_tables = std::max(
                    stage_in_source_tables,
                    table->getQueryProcessingStage(local_context, to_stage,
                        table->getStorageSnapshot(table_metadata, local_context), query_info));
            }

            iterator->next();
        }
    }

    auto stage = selected_table_size == 1 ? stage_in_source_tables : std::min(stage_in_source_tables, QueryProcessingStage::WithMergeableState);

    /// Caller asked for WithMergeableState but a child reported a higher stage
    /// (e.g. Distributed with `distributed_group_by_no_merge=1` reports Complete).
    /// Cap to WithMergeableState so we don't emit finalized values where the caller
    /// expects AggregateFunction states - otherwise `convertAndFilterSourceStream`
    /// throws CANNOT_CONVERT_TYPE. The multi-table branch above already caps at
    /// WithMergeableState for the same reason; this extends it to the single-table branch.
    ///
    /// Only when the caller asked for exactly WithMergeableState: for FetchColumns the
    /// caller wants raw columns, the child's higher stage (Complete from a single-shard