Method makePipe

src/Processors/QueryPlan/ReadFromSystemNumbersStep.cpp:461–691

}

Pipe ReadFromSystemNumbersStep::makePipe()
{
    auto & numbers_storage = storage->as<StorageSystemNumbers &>();

    /// For non-multithreaded variants (`system.numbers` / `numbers(...)`), keep a single stream to preserve ordering.
    if (!numbers_storage.multithreaded)
        num_streams = 1;

    Pipe pipe;
    const auto header = NumbersSource::createHeader(numbers_storage.column_name);

    auto add_null_source = [&] { NumbersLikeUtils::addNullSource(pipe, header); };

    /// Pushdown rationale:
    /// - Filter pushdown:
    ///   - `numbers` is a value-domain source. For bounded sources (`numbers(limit)` / `numbers(offset, limit[, step])`),
    ///     storage arguments define the table domain (with step and possible wrap), and extracted ranges are intersected
    ///     with that domain to preserve semantics while reducing generation.
    ///     Example: `SELECT number FROM numbers(10, 10) WHERE number >= 15` should read only `[15, 19]`.
    ///   - For unbounded sources (`system.numbers(_mt)` / `numbers(_mt)()`), if no useful bounds are extracted
    ///     and query LIMIT/OFFSET cannot be safely pushed down, we keep the fast unbounded generator.
    ///     Otherwise we use ranged generation from extracted ranges/bounds (or from pushed query LIMIT/OFFSET).
    ///     Example: `SELECT number FROM system.numbers WHERE number BETWEEN 100 AND 130`.
    /// - LIMIT/OFFSET pushdown:
    ///   - Safe only when extracted ranges are exact. With conservative bounds, pre-filter LIMIT may stop too early.
    ///     Example: `SELECT number FROM system.numbers WHERE number % 3 = 1 AND number < 100 LIMIT 5`.
    ///     Here `number < 100` gives only a conservative bound, so pushing LIMIT first could return too few rows
    ///     (e.g. from `[0, 1, 2, 3, 4]` we keep only `[1, 4]` instead of `[1, 4, 7, 10, 13]`).
    ///
    /// Storage-level LIMIT 0 (`numbers(..., 0, ...)`) is an empty table regardless of the WHERE clause.
    if (numbers_storage.limit.has_value() && (numbers_storage.limit.value() == 0))
    {
        add_null_source();
        return pipe;
    }

    chassert(numbers_storage.step != UInt64{0});

    /// Descending series (e.g. `generate_series(10, 0, -1)`): compute exact output count
    /// from domain size and step, then use `SimpleSteppedNumbersSource` with a wrapping step.
    /// The step stored in storage is always the positive absolute value; the wrapping trick
    /// (UInt64(0) - step) makes unsigned addition equivalent to subtraction.
    /// TODO: Support filter pushdown for negative step as well.
    if (numbers_storage.descending)
    {
        chassert(numbers_storage.limit.has_value());
        UInt128 domain_size = *numbers_storage.limit;
        UInt128 count128 = (domain_size + numbers_storage.step - 1) / numbers_storage.step;

        chassert(count128 <= std::numeric_limits<UInt64>::max());

        UInt64 total_count = static_cast<UInt64>(count128);

        /// We cannot push down LIMIT if we have a filter. Consider:
        ///   SELECT * FROM generate_series(10, 0, -1) WHERE generate_series < 3 LIMIT 1
        /// Pushing LIMIT 1 would generate only {10}, which the filter discards, returning
        /// empty instead of the correct {2}.
        if (limit.has_value() && !filter_actions_dag)