Changed-lines coverage:
  PR changed C/C++ lines covered by tests: 92.68% (291/314)

Uncovered changed code (with context):

================================================================================
src/Processors/PrefetchingConcatProcessor.h
================================================================================

--- uncovered block 36-36 ---
       34 |     Status prepare() override;
       35 | 
>>     36 |     OutputPort & getOutputPort() { return outputs.front(); }
       37 | 
       38 | private:
================================================================================
src/Processors/QueryPlan/BufferChunksTransform.cpp
================================================================================

--- uncovered block 95-97 ---
       93 |                 return Status::PortFull;
       94 |             }
>>     95 |             output.push(std::move(chunk));
>>     96 |             input.setNotNeeded();
>>     97 |             return Status::PortFull;
       98 |         }
       99 |         compactReplicatedColumns(chunk);
================================================================================
src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
================================================================================

--- uncovered block 1332-1332 ---
     1330 |                 order_info.input_order->limit);
     1331 |             if (!can_read)
>>   1332 |                 return {};
     1333 | 
     1334 |             /// Aggregation-in-order benefits from multiple input streams

--- uncovered block 1354-1354 ---
     1352 |             bool can_read = merge->requestReadingInOrder(order_info.input_order);
     1353 |             if (!can_read)
>>   1354 |                 return {};
     1355 | 
     1356 |             /// Same as the direct `ReadFromMergeTree` branch above: aggregation-in-order

--- uncovered block 1471-1471 ---
     1469 |             order_info.input_order->direction,
     1470 |             order_info.input_order->limit))
>>   1471 |             return {};
     1472 | 
     1473 |         /// Distinct-in-order's pre-distinct stage runs `DistinctSortedStreamTransform`

--- uncovered block 1479-1479 ---
     1477 | 
     1478 |         for (auto * join_step : find_reading_ctx.joins_to_keep_in_order)
>>   1479 |             join_step->keepLeftPipelineInOrder(/* disable_squashing */ true);
     1480 |         return order_info;
     1481 |     }

--- uncovered block 1499-1508 ---
     1497 |         }
     1498 | 
>>   1499 |         if (!merge->requestReadingInOrder(order_info.input_order))
>>   1500 |             return {};
     1501 | 
     1502 |         /// Distinct-in-order's pre-distinct stage runs per stream, so keep multiple
     1503 |         /// parallel input streams instead of collapsing them with `PrefetchingConcat`.
>>   1504 |         merge->setPreferMultipleStreams();
     1505 | 
>>   1506 |         for (auto * join_step : find_reading_ctx.joins_to_keep_in_order)
>>   1507 |             join_step->keepLeftPipelineInOrder(/* disable_squashing */ true);
>>   1508 |         return order_info;
     1509 |     }
     1510 | 

--- uncovered block 1576-1576 ---
     1574 |         if (!reading->requestReadingInOrder(
     1575 |                 order_info.input_order->used_prefix_of_sorting_key_size, order_info.input_order->direction, order_info.input_order->limit))
>>   1576 |             return {};
     1577 | 
     1578 |         /// This overload only fires without an upstream ORDER BY (otherwise the SortingStep

--- uncovered block 1587-1587 ---
     1585 | 
     1586 |         for (auto * join_step : find_reading_ctx.joins_to_keep_in_order)
>>   1587 |             join_step->keepLeftPipelineInOrder(/* disable_squashing */ true);
     1588 |         return order_info;
     1589 |     }

--- uncovered block 1603-1603 ---
     1601 | 
     1602 |         if (!merge->requestReadingInOrder(order_info.input_order))
>>   1603 |             return {};
     1604 | 
     1605 |         /// Same as the direct `ReadFromMergeTree` branch: LIMIT BY in streaming mode runs

--- uncovered block 1611-1611 ---
     1609 | 
     1610 |         for (auto * join_step : find_reading_ctx.joins_to_keep_in_order)
>>   1611 |             join_step->keepLeftPipelineInOrder(/* disable_squashing */ true);
     1612 |         return order_info;
     1613 |     }
================================================================================
src/Storages/StorageMerge.cpp
================================================================================

--- uncovered block 1239-1239 ---
     1237 |     /// can only be reached through the nested step itself.
     1238 |     else if (auto * read_from_merge = typeid_cast<ReadFromMerge *>(node->step.get()))
>>   1239 |         ok &= merge_func(*read_from_merge);
     1240 | 
     1241 |     return ok;

--- uncovered block 1758-1758 ---
     1756 |     auto request_read_in_order_nested = [order_info_, query_limit](ReadFromMerge & nested_read_from_merge)
     1757 |     {
>>   1758 |         return nested_read_from_merge.requestReadingInOrder(order_info_, query_limit);
     1759 |     };
     1760 | 

--- uncovered block 1767-1767 ---
     1765 | 
     1766 |     if (!ok)
>>   1767 |         return false;
     1768 | 
     1769 |     order_info = order_info_;

--- uncovered block 1786-1787 ---
     1784 |     auto prefer_multiple_streams_nested = [](ReadFromMerge & nested_read_from_merge)
     1785 |     {
>>   1786 |         nested_read_from_merge.setPreferMultipleStreams();
>>   1787 |         return true;
     1788 |     };
     1789 | 
WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set

--- Coverage counts ---
Lines     : baseline 896,042/1,041,131  ->  current 897,333/1,041,412  (delta +1,291 / +281)
Functions : baseline 837,786/912,754  ->  current 837,873/912,768  (delta +87 / +14)
Branches  : baseline 290,223/371,148  ->  current 290,746/371,294  (delta +523 / +146)