Function mainQueryNodeBlockSizeByLimit

src/Planner/PlannerJoinTree.cpp:703–767

}

UInt64 mainQueryNodeBlockSizeByLimit(const SelectQueryInfo & select_query_info)
{
    // Since we support negative limit, query node field could potentially be Int64 implying negative value.
    // So, we have to handle to separately
    auto const & main_query_node = select_query_info.query_tree->as<QueryNode const &>();

    /// Constness of limit and offset is validated during query analysis stage
    UInt64 limit_length = 0;
    if (main_query_node.hasLimit())
    {
        const auto & field = main_query_node.getLimit()->as<ConstantNode &>().getValue();

        const bool is_uint64 = !convertFieldToType(field, DataTypeUInt64()).isNull();

        // Negative LIMIT, skip optimization
        if (!is_uint64)
            return 0;

        limit_length = field.safeGet<UInt64>();
    }

    UInt64 limit_offset = 0;
    if (main_query_node.hasOffset())
    {
        const auto & field = main_query_node.getOffset()->as<ConstantNode &>().getValue();
        const bool is_uint64 = !convertFieldToType(field, DataTypeUInt64()).isNull();

        // Negative OFFSET, skip optimization
        if (!is_uint64)
            return 0;

        limit_offset = field.safeGet<UInt64>();
    }

    /// `arrayJoin` in the projection expands one input row into several output rows after the
    /// source has run. Capping the source to `limit + offset` rows would truncate input BEFORE
    /// expansion, so hard consumers of `trivial_limit` (StorageLoop, system.zeros, generateRandom)
    /// could drop output rows that the LIMIT should keep. See issue #82279 and the sibling guard
    /// in `numbersLikeUtils::shouldPushdownLimit`. (The `ARRAY JOIN` clause is lowered to a
    /// separate table expression in the analyzer, so it is not a single-table read and never
    /// reaches this optimization.)
    if (hasFunctionNode(main_query_node.getProjectionNode(), "arrayJoin"))
        return 0;

    /** If not specified DISTINCT, WHERE, GROUP BY, HAVING, ORDER BY, JOIN, LIMIT BY, LIMIT WITH TIES
      * but LIMIT is specified with UInt64 value, and limit + offset < max_block_size,
      * then as the block size we will use limit + offset (not to read more from the table than requested),
      * and also set the number of threads to 1.
      */
    if (main_query_node.hasLimit()
        && !main_query_node.isDistinct()
        && !main_query_node.isLimitWithTies()
        && !main_query_node.hasPrewhere()
        && !main_query_node.hasWhere()
        && select_query_info.filter_asts.empty()
        && !main_query_node.hasGroupBy()
        && !main_query_node.hasHaving()
        && !main_query_node.hasOrderBy()