Method ExpressionAnalysisResult

src/Interpreters/ExpressionAnalyzer.cpp:2072–2425

}

ExpressionAnalysisResult::ExpressionAnalysisResult(
        SelectQueryExpressionAnalyzer & query_analyzer,
        const StorageMetadataPtr & metadata_snapshot,
        bool first_stage_,
        bool second_stage_,
        bool only_types,
        const FilterDAGInfoPtr & filter_info_,
        const Block & source_header,
        const std::vector<ASTPtr> & additional_predicates)
    : first_stage(first_stage_)
    , second_stage(second_stage_)
    , need_aggregate(query_analyzer.hasAggregation())
    , has_window(query_analyzer.hasWindow())
    , use_grouping_set_key(query_analyzer.useGroupingSetKey())
{
    /// first_stage: Do I need to perform the first part of the pipeline - running on remote servers during distributed processing.
    /// second_stage: Do I need to execute the second part of the pipeline - running on the initiating server during distributed processing.

    /** First we compose a chain of actions and remember the necessary steps from it.
        *  Regardless of from_stage and to_stage, we will compose a complete sequence of actions to perform optimization and
        *  throw out unnecessary columns based on the entire query. In unnecessary parts of the query, we will not execute subqueries.
        */

    const ASTSelectQuery & query = *query_analyzer.getSelectQuery();
    auto context = query_analyzer.getContext();
    const Settings & settings = context->getSettingsRef();
    const ConstStoragePtr & storage = query_analyzer.storage();
    Block precomputed_header;
    auto index_context = query_analyzer.getIndexContext();
    if (auto * bitmap_index_info = dynamic_cast<BitmapIndexInfo *>(index_context->get(MergeTreeIndexInfo::Type::BITMAP).get()))
    {
        for (auto & ele : bitmap_index_info->return_types)
        {
            if (ele.second == BitmapIndexReturnType::EXPRESSION)
                precomputed_header.insert({std::make_shared<DataTypeUInt8>(), ele.first});
        }
    }

    bool finalized = false;
    size_t where_step_num = 0;

    auto finalize_chain = [&](ExpressionActionsChain & chain) {
        chain.finalize();

        if (!finalized)
        {
            finalize(chain, where_step_num, query);
            finalized = true;
        }

        // fmt::print("After finallize ---------- \n{}\n", chain.dumpChain());

        chain.clear();
    };

    if (storage)
    {
        query_analyzer.makeSetsForIndex(query.where());