Method executeFetchColumns

src/Interpreters/InterpreterSelectQuery.cpp:2084–2444

}

void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum processing_stage, QueryPlan & query_plan)
{
    auto & query = getSelectQuery();
    const Settings & settings = context->getSettingsRef();

    /// Optimization for trivial query like SELECT count() FROM table.
    bool optimize_trivial_count =
        syntax_analyzer_result->optimize_trivial_count
        && (settings.max_parallel_replicas <= 1)
        && storage
        && storage->getName() != "MaterializeMySQL"
        && !row_policy_filter
        /*
        ** Trivial count optimization for StorageCnchMergeTree. In original Clickhouse implementation,
        ** high-level storage cannot support trival count, but StorageCnchMergeTree is special because it
        ** HAS own metadata.
        */
        && (processing_stage == QueryProcessingStage::FetchColumns || storage->supportsTrivialCount())
        && query_analyzer->hasAggregation()
        && (query_analyzer->aggregates().size() == 1)
        && typeid_cast<const AggregateFunctionCount *>(query_analyzer->aggregates()[0].function.get())
        /*
        ** disable optimize_trival_count since distributed_stages mode cannot read data from local.
        */
        && !options.distributed_stages;

    if (optimize_trivial_count)
    {
        const auto & desc = query_analyzer->aggregates()[0];
        const auto & func = desc.function;
        std::optional<UInt64> num_rows{};

        if (!query.prewhere() && !query.where() && !query_info.partition_filter && atomic_predicates_expr.empty())
        {
            num_rows = storage->totalRows(context);
        }
        else // It's possible to optimize count() given only partition predicates
        {
            SelectQueryInfo temp_query_info;
            temp_query_info.query = query_ptr;
            temp_query_info.syntax_analyzer_result = syntax_analyzer_result;
            temp_query_info.sets = query_analyzer->getPreparedSets();
            if (query_info.partition_filter)
                temp_query_info.partition_filter = query_info.partition_filter->clone();
            temp_query_info.atomic_predicates_expr = atomic_predicates_expr;

            num_rows = storage->totalRowsByPartitionPredicate(temp_query_info, context);
        }

        if (num_rows)
        {
            const AggregateFunctionCount & agg_count = static_cast<const AggregateFunctionCount &>(*func);

            /// We will process it up to "WithMergeableState".
            std::vector<char> state(agg_count.sizeOfData());
            AggregateDataPtr place = state.data();

            agg_count.create(place);