```sql
SELECT count()
FROM 
(
    SELECT number
    FROM numbers_mt(100000000)
    ORDER BY number DESC
    LIMIT 100
    UNION ALL
    SELECT number
    FROM numbers_mt(100000000)
    ORDER BY number DESC
    LIMIT 100
    UNION ALL
    SELECT number
    FROM numbers_mt(100000000)
    ORDER BY number DESC
    LIMIT 100
)


SET experimental_use_processors = 0;
-- 1 rows in set. Elapsed: 1.581 sec. Processed 300.00 million rows, 2.40 GB (189.78 million rows/s., 1.52 GB/s.) 

SET experimental_use_processors = 1;
-- 1 rows in set. Elapsed: 3.569 sec. Processed 300.00 million rows, 2.40 GB (84.06 million rows/s., 672.50 MB/s.) 
```

Similar for MergeTree:

```sql
create table test engine=MergeTree order by tuple() as select * from numbers(30000000);

select count() from (select number from test group by number order by number limit 10 union all select number from test group by number order by number limit 10);

set experimental_use_processors=0;
-- Elapsed: 2.664 sec

set experimental_use_processors=1;
-- Elapsed: 3.656 sec
```
connect(*extremes_port, extremes);
    streams.clear();
    current_header.clear();
    extremes_port = nullptr;
    totals_having_port = nullptr;
    initRowsBeforeLimit();
}
void QueryPipeline::unitePipelines(
    std::vector<std::unique_ptr<QueryPipeline>> pipelines, const Block & common_header)
{
    if (initialized())
    {
        addSimpleTransform([&](const Block & header)
        {
            return std::make_shared<ConvertingTransform>(
                    header, common_header, ConvertingTransform::MatchColumnsMode::Position);
        });
    }
    std::vector<OutputPort *> extremes;
    std::vector<OutputPort *> totals;
    if (extremes_port)
        extremes.push_back(extremes_port);
    if (totals_having_port)
        totals.push_back(totals_having_port);
    for (auto & pipeline_ptr : pipelines)
    {
        auto & pipeline = *pipeline_ptr;
        pipeline.checkInitialized();
        pipeline.processors.setCollectedProcessors(processors.getCollectedProcessors());
        if (!pipeline.isCompleted())