Method ExpressionAnalysisResult

src/Interpreters/ExpressionAnalyzer.cpp:1989–2343

}

ExpressionAnalysisResult::ExpressionAnalysisResult(
    SelectQueryExpressionAnalyzer & query_analyzer,
    const StorageMetadataPtr & metadata_snapshot,
    bool first_stage_,
    bool second_stage_,
    bool only_types,
    const FilterDAGInfoPtr & row_policy_info_,
    const FilterDAGInfoPtr & additional_filter,
    const Block & source_header)
    : 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();

    Names additional_required_columns_after_prewhere;
    ssize_t prewhere_step_num = -1;
    ssize_t where_step_num = -1;
    ssize_t having_step_num = -1;

    ActionsAndProjectInputsFlagPtr prewhere_dag_and_flags;

    auto finalize_chain = [&](ExpressionActionsChain & chain) -> ColumnsWithTypeAndName
    {
        if (prewhere_step_num >= 0)
        {
            ExpressionActionsChainSteps::Step & step = *chain.steps.at(prewhere_step_num);

            auto prewhere_required_columns = prewhere_dag_and_flags->dag.getRequiredColumnsNames();
            NameSet required_source_columns(prewhere_required_columns.begin(), prewhere_required_columns.end());
            /// Add required columns to required output in order not to remove them after prewhere execution.
            /// TODO: add sampling and final execution to common chain.
            for (const auto & column : additional_required_columns_after_prewhere)
            {
                if (required_source_columns.contains(column))
                    step.addRequiredOutput(column);
            }
        }

        chain.finalize();

        if (prewhere_dag_and_flags)
        {
            prewhere_info = std::make_shared<PrewhereInfo>(std::move(prewhere_dag_and_flags->dag), query.prewhere()->getColumnName());
            prewhere_dag_and_flags.reset();