Changed-lines coverage:
  PR changed C/C++ lines covered by tests: 91.52% (259/283)

Uncovered changed code (with context):

================================================================================
src/Processors/Formats/Impl/NativeORCBlockInputFormat.cpp
================================================================================

--- uncovered block 834-838 ---
      832 |         }
      833 |         /// There is no optimization with space-filling curves for ORC.
>>    834 |         case KeyCondition::RPNElement::FUNCTION_ARGS_IN_HYPERRECTANGLE:
      835 |         /// There is no optimization with pointInPolygon for ORC.
>>    836 |         case KeyCondition::RPNElement::FUNCTION_POINT_IN_POLYGON:
      837 |         /// There is no optimization with lexicographic tuple comparison for ORC.
>>    838 |         case KeyCondition::RPNElement::FUNCTION_TUPLE_LEXICOGRAPHIC:
      839 |         case KeyCondition::RPNElement::FUNCTION_UNKNOWN:
      840 |         {
================================================================================
src/Storages/MergeTree/KeyCondition.cpp
================================================================================

--- uncovered block 3858-3862 ---
     3856 |     Field converted = tryConvertFieldToType(value, *key_type_not_null, from_type.get());
     3857 |     if (converted.isNull())
>>   3858 |         return std::nullopt;
     3859 | 
     3860 |     Field back = tryConvertFieldToType(converted, *from_type, key_type_not_null.get());
     3861 |     if (back.isNull() || !Range::equals(back, value))
>>   3862 |         return std::nullopt;
     3863 | 
     3864 |     return converted;

--- uncovered block 3898-3905 ---
     3896 |     /// The constant side must be a tuple of the same size.
     3897 |     if (const_value.getType() != Field::Types::Tuple)
>>   3898 |         return false;
     3899 |     const Tuple & const_tuple = const_value.safeGet<Tuple>();
     3900 |     if (const_tuple.size() != tuple_size)
>>   3901 |         return false;
     3902 | 
     3903 |     const auto * const_tuple_type = typeid_cast<const DataTypeTuple *>(const_type.get());
     3904 |     if (!const_tuple_type || const_tuple_type->getElements().size() != tuple_size)
>>   3905 |         return false;
     3906 |     const auto & const_elem_types = const_tuple_type->getElements();
     3907 | 

--- uncovered block 3929-3929 ---
     3927 |         /// A NULL or NaN constant element makes the comparison SQL-unknown from this element on; stop.
     3928 |         if (value.isNull() || value.isNaN())
>>   3929 |             break;
     3930 | 
     3931 |         size_t key_column_num = std::numeric_limits<size_t>::max();

--- uncovered block 3951-3951 ---
     3949 |         std::optional<Field> converted = convertTupleLexicographicConstant(key_type_not_null, from_type, value);
     3950 |         if (!converted)
>>   3951 |             break;
     3952 | 
     3953 |         mapped_key_columns.push_back(key_column_num);

--- uncovered block 3982-3982 ---
     3980 |         out.monotonic_functions_chain = std::move(mapped_chains[0]);
     3981 |         if (greater)
>>   3982 |             out.range = Range::createLeftBounded(mapped_constant[0], !strict);
     3983 |         else
     3984 |             out.range = Range::createRightBounded(mapped_constant[0], !strict);

--- uncovered block 6294-6308 ---
     6292 |                 if (kc >= hyperrectangle.size())
     6293 |                 {
>>   6294 |                     indeterminate = true;
>>   6295 |                     break;
     6296 |                 }
     6297 | 
     6298 |                 Range range = hyperrectangle[kc];
     6299 |                 if (i < chains.size() && !chains[i].empty())
     6300 |                 {
>>   6301 |                     std::optional<Range> new_range
>>   6302 |                         = applyMonotonicFunctionsChainToRange(range, chains[i], data_types[kc], single_point);
>>   6303 |                     if (!new_range)
     6304 |                     {
>>   6305 |                         indeterminate = true;
>>   6306 |                         break;
     6307 |                     }
>>   6308 |                     range = std::move(*new_range);
     6309 |                 }
     6310 |                 elem_ranges.push_back(std::move(range));

--- uncovered block 6315-6315 ---
     6313 |             if (indeterminate)
     6314 |             {
>>   6315 |                 rpn_stack.emplace_back(true, true);
     6316 |             }
     6317 |             else

--- uncovered block 6323-6323 ---
     6321 | 
     6322 |                 if (element.relaxed)
>>   6323 |                     rpn_stack.back().can_be_false = true;
     6324 |             }
     6325 |         }

--- uncovered block 6847-6848 ---
     6845 |                     if (!new_range)
     6846 |                     {
>>   6847 |                         indeterminate = true;
>>   6848 |                         break;
     6849 |                     }
     6850 |                     range = std::move(*new_range);

--- uncovered block 6857-6857 ---
     6855 |             if (indeterminate || elem_ranges.empty())
     6856 |             {
>>   6857 |                 rpn_stack.emplace_back(true, true);
     6858 |             }
     6859 |             else
WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set

--- Coverage counts ---
Lines     : baseline 934,106/1,079,624  ->  current 934,304/1,079,908  (delta +198 / +284)
Functions : baseline 805,638/876,857  ->  current 805,724/876,862  (delta +86 / +5)
Branches  : baseline 305,851/388,434  ->  current 305,850/388,614  (delta -1 / +180)