Method QueryAnalysisResult

src/Planner/Planner.cpp:463–541

{
public:
    QueryAnalysisResult(const QueryTreeNodePtr & query_tree,
        const PlannerQueryProcessingInfo & query_processing_info,
        const PlannerContextPtr & planner_context)
    {
        const auto & query_node = query_tree->as<QueryNode &>();
        const auto & query_context = planner_context->getQueryContext();
        const auto & settings = query_context->getSettingsRef();

        aggregate_overflow_row = query_node.isGroupByWithTotals() && settings[Setting::max_rows_to_group_by]
            && settings[Setting::group_by_overflow_mode] == OverflowMode::ANY && settings[Setting::totals_mode] != TotalsMode::AFTER_HAVING_EXCLUSIVE;
        aggregate_final = query_processing_info.getToStage() > QueryProcessingStage::WithMergeableState
            && !query_node.isGroupByWithTotals() && !query_node.isGroupByWithRollup() && !query_node.isGroupByWithCube();
        aggregation_with_rollup_or_cube_or_grouping_sets = query_node.isGroupByWithRollup() || query_node.isGroupByWithCube() ||
            query_node.isGroupByWithGroupingSets();
        aggregation_should_produce_results_in_order_of_bucket_number
            = query_processing_info.getToStage() == QueryProcessingStage::WithMergeableState
            && (settings[Setting::distributed_aggregation_memory_efficient] || settings[Setting::enable_memory_bound_merging_of_aggregation_results]);

        query_has_array_join_in_join_tree = queryHasArrayJoinInJoinTree(query_tree);
        query_has_with_totals_in_any_subquery_in_join_tree = queryHasWithTotalsInAnySubqueryInJoinTree(query_tree);

        sort_description = extractSortDescription(query_node.getOrderByNode(), *planner_context);

        if (query_node.hasLimit())
        {
            /// Constness of limit is validated during query analysis stage
            std::tie(limit_length, fractional_limit, is_limit_length_negative)
                = getLimitOffsetValue(query_node.getLimit()->as<ConstantNode &>().getValue());

            if (query_node.hasOffset() && (limit_length || fractional_limit > 0))
            {
                /// Constness of offset is validated during query analysis stage
                std::tie(limit_offset, fractional_offset, is_limit_offset_negative)
                    = getLimitOffsetValue(query_node.getOffset()->as<ConstantNode &>().getValue());
            }
        }
        else if (query_node.hasOffset())
        {
            /// Constness of offset is validated during query analysis stage
            std::tie(limit_offset, fractional_offset, is_limit_offset_negative)
                = getLimitOffsetValue(query_node.getOffset()->as<ConstantNode &>().getValue());
        }

        /// Partial sort can be done if there is LIMIT, but no DISTINCT, LIMIT WITH TIES, LIMIT BY, ARRAY JOIN, NEGATIVE LIMIT, FRACTIONAL LIMIT/OFFSET
        if (limit_length != 0 &&
            !query_node.isDistinct() &&
            !query_node.isLimitWithTies() &&
            !query_node.hasLimitBy() &&
            !query_has_array_join_in_join_tree &&
            fractional_offset == 0 &&
            fractional_limit == 0 &&
            limit_length <= std::numeric_limits<UInt64>::max() - limit_offset &&
            !is_limit_length_negative)
        {
            partial_sorting_limit = limit_length + limit_offset;
        }

        if (query_node.hasLimitBy())