Method generate

src/Processors/Transforms/NegativeLimitByTransform.cpp:258–339

}

Chunk NegativeLimitByTransform::generate()
{
    if (!offset_rows_dropped)
    {
        /// Drop trailing `offset` rows per group, then release the hash table and per-group
        /// state - from here on `candidate_list` alone carries the answer in input order.
        for (auto & window : group_windows)
            dropOffsetRows(window);
        offset_rows_dropped = true;
        releaseHashTable(data);
        hash_method_context.reset();
        std::vector<GroupWindow>{}.swap(group_windows);
    }

    if (candidate_list.empty())
        return {};

    /// At this point, `candidate_list` contains all the rows that will be part of the output.
    /// Per grouping key we have at most `group_length` rows. `candidate_list` holds the data in
    /// input order, so we can emit from the head of the list.

    /// Coalesce consecutive slices sharing one source chunk into a single output chunk.
    /// This avoids emitting many tiny chunks when the grouping key has high cardinality.
    auto coalesce_slice_begin = candidate_list.begin();
    auto columns_ptr = coalesce_slice_begin->columns;
    auto coalesce_slice_end = std::next(coalesce_slice_begin);
    while (coalesce_slice_end != candidate_list.end() && coalesce_slice_end->columns == columns_ptr)
        ++coalesce_slice_end;

    Chunk chunk;
    if (std::next(coalesce_slice_begin) == coalesce_slice_end) /// Only one slice in the chunk
    {
        chunk = materializeSliceToChunkIfNeeded(*coalesce_slice_begin);
    }
    else
    {
        const Columns & source = *columns_ptr;
        UInt64 chunk_size = source.front()->size();

        /// Compute some statistics to pick an optimized materialization strategy below.
        UInt64 num_output_rows = 0;
        UInt64 first_slice_start_row = coalesce_slice_begin->start;
        UInt64 last_slice_end_row = 0;
        for (auto it = coalesce_slice_begin; it != coalesce_slice_end; ++it)
        {
            num_output_rows += it->length;
            last_slice_end_row = it->start + it->length;
        }

        if (num_output_rows == chunk_size)
        {
            /// Every row of the source chunk survived across different keys.
            chunk = Chunk(Columns(source), num_output_rows);
        }
        else if (last_slice_end_row - first_slice_start_row == num_output_rows)
        {
            /// Slices form one contiguous segment - single cut per column, which is more efficient than mask+filter.
            Columns result;