80.60% (108/134)

Uncovered changed code (with context):

================================================================================
src/Analyzer/Passes/DictGetTupleElementPass.cpp
================================================================================

--- uncovered block 40-40 ---
       38 |                 return i;
       39 |         }
>>     40 |         return std::nullopt;
       41 |     }
       42 | 

--- uncovered block 50-50 ---
       48 |     }
       49 | 
>>     50 |     return std::nullopt;
       51 | }
       52 | 

--- uncovered block 70-70 ---
       68 |             {
       69 |                 if (elem.getType() != Field::Types::String)
>>     70 |                     return {};
       71 |                 result.push_back(elem.safeGet<String>());
       72 |             }

--- uncovered block 76-76 ---
       74 |         }
       75 |     }
>>     76 |     else if (const auto * function_node = arg->as<FunctionNode>())
       77 |     {
       78 |         if (function_node->getFunctionName() == "tuple")

--- uncovered block 78-78 ---
       76 |     else if (const auto * function_node = arg->as<FunctionNode>())
       77 |     {
>>     78 |         if (function_node->getFunctionName() == "tuple")
       79 |         {
       80 |             for (const auto & child : function_node->getArguments().getNodes())

--- uncovered block 80-80 ---
       78 |         if (function_node->getFunctionName() == "tuple")
       79 |         {
>>     80 |             for (const auto & child : function_node->getArguments().getNodes())
       81 |             {
       82 |                 const auto * child_constant = child->as<ConstantNode>();

--- uncovered block 82-84 ---
       80 |             for (const auto & child : function_node->getArguments().getNodes())
       81 |             {
>>     82 |                 const auto * child_constant = child->as<ConstantNode>();
>>     83 |                 if (!child_constant)
>>     84 |                     return {};
       85 | 
       86 |                 Field value = child_constant->getValue();

--- uncovered block 86-88 ---
       84 |                     return {};
       85 | 
>>     86 |                 Field value = child_constant->getValue();
>>     87 |                 if (value.getType() != Field::Types::String)
>>     88 |                     return {};
       89 | 
       90 |                 result.push_back(value.safeGet<String>());

--- uncovered block 90-90 ---
       88 |                     return {};
       89 | 
>>     90 |                 result.push_back(value.safeGet<String>());
       91 |             }
       92 |             return result;

--- uncovered block 92-92 ---
       90 |                 result.push_back(value.safeGet<String>());
       91 |             }
>>     92 |             return result;
       93 |         }
       94 |     }

--- uncovered block 135-135 ---
      133 |         /// dictGetOrDefault has at least 4: dict_name, attr_names, key_expr, default_value [, ...]
      134 |         if (dict_get_args.size() < 3)
>>    135 |             return;
      136 | 
      137 |         /// Extract attribute names from the second argument

--- uncovered block 145-145 ---
      143 |         const auto * index_node = tuple_element_args[1]->as<ConstantNode>();
      144 |         if (!index_node)
>>    145 |             return;
      146 | 
      147 |         auto maybe_index = getTupleElementIndex(*index_node, attribute_names);

--- uncovered block 149-149 ---
      147 |         auto maybe_index = getTupleElementIndex(*index_node, attribute_names);
      148 |         if (!maybe_index)
>>    149 |             return;
      150 | 
      151 |         size_t element_index = *maybe_index;

--- uncovered block 174-174 ---
      172 |             const auto * result_tuple_type = typeid_cast<const DataTypeTuple *>(dict_get_function->getResultType().get());
      173 |             if (!default_tuple_type || !result_tuple_type)
>>    174 |                 return;
      175 | 
      176 |             const auto & default_elems = default_tuple_type->getElements();

--- uncovered block 179-179 ---
      177 |             const auto & result_elems = result_tuple_type->getElements();
      178 |             if (default_elems.size() != result_elems.size())
>>    179 |                 return;
      180 |             for (size_t i = 0; i < default_elems.size(); ++i)
      181 |                 if (!default_elems[i]->equals(*result_elems[i]))

--- uncovered block 182-182 ---
      180 |             for (size_t i = 0; i < default_elems.size(); ++i)
      181 |                 if (!default_elems[i]->equals(*result_elems[i]))
>>    182 |                     return;
      183 | 
      184 |             if (const auto * default_constant = default_arg->as<ConstantNode>())

--- uncovered block 193-193 ---
      191 |                         new_default_arg = std::make_shared<ConstantNode>(default_tuple[element_index]);
      192 |                     else
>>    193 |                         return; /// Cannot optimize — index out of range
      194 |                 }
      195 |             }

--- uncovered block 202-202 ---
      200 |                     const auto & default_tuple_args = default_function->getArguments().getNodes();
      201 |                     if (element_index >= default_tuple_args.size())
>>    202 |                         return; /// Cannot optimize — index out of range
      203 | 
      204 |                     /// Only rewrite when all tuple arguments are constants. Otherwise, dropping the

--- uncovered block 218-218 ---
      216 | 
      217 |                     if (all_constants)
>>    218 |                         new_default_arg = default_tuple_args[element_index];
      219 |                 }
      220 |             }

--- uncovered block 251-251 ---
      249 |         /// node and break the surrounding query tree. Bail out in that case.
      250 |         if (!new_dict_get_function.getResultType()->equals(*tuple_element_function->getResultType()))
>>    251 |             return;
      252 | 
      253 |         node = std::move(new_dict_get_node);
================================================================================
src/Analyzer/Passes/DictGetTupleElementPass.h
================================================================================

--- uncovered block 19-19 ---
       17 | {
       18 | public:
>>     19 |     String getName() override { return "DictGetTupleElement"; }
       20 | 
       21 |     String getDescription() override { return "Optimize tupleElement(dictGet(..., tuple_of_attrs, ...), index) into dictGet(..., single_attr, ...)"; }

--- uncovered block 21-21 ---
       19 |     String getName() override { return "DictGetTupleElement"; }
       20 | 
>>     21 |     String getDescription() override { return "Optimize tupleElement(dictGet(..., tuple_of_attrs, ...), index) into dictGet(..., single_attr, ...)"; }
       22 | 
       23 |     void run(QueryTreeNodePtr & query_tree_node, ContextPtr context) override;
No lost baseline coverage found.
WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set

--- Coverage counts ---
Lines     : baseline 756,271/899,464  ->  current 756,348/899,627  (delta +77 / +163)
Functions : baseline 830,441/911,552  ->  current 830,515/911,581  (delta +74 / +29)
Branches  : baseline 245,675/320,800  ->  current 245,722/320,890  (delta +47 / +90)