```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
```
{
    public:
        bool empty() const { return processors.empty(); }
        void emplace(ProcessorPtr processor);
        void emplace(Processors processors_);
        Processors * getCollectedProcessors() const { return collected_processors; }
        Processors * setCollectedProcessors(Processors * collected_processors);
        Processors & get() { return processors; }
        const Processors & get() const { return processors; }
        Processors detach() { return std::move(processors); }
    private:
        
        Processors processors;
        
        
        Processors * collected_processors = nullptr;
    };
    QueryPipeline() = default;
    QueryPipeline(QueryPipeline &&) = default;
    ~QueryPipeline() = default;
    QueryPipeline(const QueryPipeline &) = delete;
    QueryPipeline & operator= (const QueryPipeline & rhs) = delete;
    QueryPipeline & operator= (QueryPipeline && rhs);
    
    void init(Pipes pipes);
    void init(Pipe pipe); 
    bool initialized() { return !processors.empty(); }