20.10.1.4853

```sql
drop table if exists xp;
drop table if exists xp_d;

create table xp(A Date, B Int64, S String) Engine=MergeTree partition by toYYYYMM(A) order by B;
insert into xp select '2020-01-01', number , '' from numbers(100000);
insert into xp select '2020-10-01', number , '' from numbers(100000);
create table xp_d as xp Engine=Distributed(test_shard_localhost, currentDatabase(), xp);

select count() from xp_d prewhere toYYYYMM(A) global in (select toYYYYMM(min(A)) from xp_d) where B > -1;
┌─count()─┐
│       0 │     <------ expected 100000
└─────────┘

-- global in & both predicates in prewhere 
select count() from xp_d prewhere toYYYYMM(A) global in (select toYYYYMM(min(A)) from xp_d) and B > -1;
┌─count()─┐
│  100000 │
└─────────┘

-- global in & both predicates in where 
select count() from xp_d where toYYYYMM(A) global in (select toYYYYMM(min(A)) from xp_d) and B > -1;
┌─count()─┐
│  100000 │
└─────────┘

-- not global
select count() from xp_d prewhere toYYYYMM(A) in (select toYYYYMM(min(A)) from xp_d) where B > -1;
┌─count()─┐
│  100000 │
└─────────┘



select count() from xp_d prewhere toYYYYMM(A) global in (select 202001) where B > -1;
┌─count()─┐
│       0 │
└─────────┘
```

hmm, it worked in 19.13.7.57
throw Exception("Logical error: zero number of streams requested", ErrorCodes::LOGICAL_ERROR);
        
        if (max_streams > 1 && !is_remote)
            max_streams *= settings.max_streams_to_max_threads_ratio;
        query_info.query = query_ptr;
        query_info.syntax_analyzer_result = syntax_analyzer_result;
        query_info.sets = query_analyzer->getPreparedSets();
        query_info.prewhere_info = prewhere_info;
        
        
        if (analysis_result.optimize_read_in_order || analysis_result.optimize_aggregation_in_order)
        {
            if (analysis_result.optimize_read_in_order)
                query_info.order_optimizer = std::make_shared<ReadInOrderOptimizer>(
                    analysis_result.order_by_elements_actions,
                    getSortDescription(query, *context),
                    query_info.syntax_analyzer_result);
            else
                query_info.order_optimizer = std::make_shared<ReadInOrderOptimizer>(
                    analysis_result.group_by_elements_actions,
                    getSortDescriptionFromGroupBy(query),
                    query_info.syntax_analyzer_result);
            query_info.input_order_info = query_info.order_optimizer->getInputOrder(storage, metadata_snapshot);
        }
        StreamLocalLimits limits;
        SizeLimits leaf_limits;
        std::shared_ptr<const EnabledQuota> quota;
        
        if (!options.ignore_limits)
        {