================================================================================ Changed-lines coverage summary ================================================================================ Denominator: lines added/modified by this PR in C/C++ source files that LCOV considers coverable (excludes blank lines, braces, comments, header-only declarations, and error-path noise such as `LOGICAL_ERROR`, `UNREACHABLE()`, `abort()`). Numerator: of those coverable lines, the number actually executed by the test suite during this coverage run. PR changed C/C++ lines covered by tests: 84.62% (1001/1183) Uncovered changed code (with context): ================================================================================ src/Columns/ColumnAggregateFunction.cpp ================================================================================ --- uncovered block 457-466 --- 455 | void ColumnAggregateFunction::computeHashInto(size_t row_begin, size_t row_end, uint32_t * hash_out, bool initial) const 456 | { >> 457 | VectorWithMemoryTracking v; >> 458 | for (size_t i = row_begin; i < row_end; ++i) 459 | { 460 | { >> 461 | WriteBufferFromVector> wbuf(v); >> 462 | func->serialize(data[i], wbuf, version); 463 | } >> 464 | const uint32_t value = ::updateWeakHash32(v.data(), v.size(), WEAK_HASH32_INITIAL_VALUE); >> 465 | uint32_t & out = hash_out[i - row_begin]; >> 466 | out = initial ? value : combineWeakHash32(value, out); 467 | } 468 | } ================================================================================ src/Columns/ColumnBLOB.h ================================================================================ --- uncovered block 164-170 --- 162 | std::string_view serializeValueIntoArena(size_t, Arena &, char const *&, const IColumn::SerializationSettings *) const override { throwInapplicable(); } 163 | char * serializeValueIntoMemory(size_t, char *, const IColumn::SerializationSettings *) const override { throwInapplicable(); } >> 164 | void deserializeAndInsertFromArena(ReadBuffer &, const IColumn::SerializationSettings *) override { throwInapplicable(); } >> 165 | void skipSerializedInArena(ReadBuffer &) const override { throwInapplicable(); } >> 166 | void updateHashWithValue(size_t, SipHash &) const override { throwInapplicable(); } >> 167 | void computeHashInto(size_t, size_t, uint32_t *, bool) const override { throwInapplicable(); } >> 168 | void updateHashFast(SipHash &) const override { throwInapplicable(); } 169 | >> 170 | ColumnPtr filter(const Filter &, ssize_t) const override { throwInapplicable(); } 171 | void filter(const Filter &) override { throwInapplicable(); } 172 | void expand(const Filter &, bool) override { throwInapplicable(); } ================================================================================ src/Columns/ColumnCompressed.h ================================================================================ --- uncovered block 102-108 --- 100 | std::string_view serializeValueIntoArena(size_t, Arena &, char const *&, const IColumn::SerializationSettings *) const override { throwMustBeDecompressed(); } 101 | char * serializeValueIntoMemory(size_t, char *, const IColumn::SerializationSettings *) const override { throwMustBeDecompressed(); } >> 102 | void deserializeAndInsertFromArena(ReadBuffer &, const IColumn::SerializationSettings *) override { throwMustBeDecompressed(); } >> 103 | void skipSerializedInArena(ReadBuffer &) const override { throwMustBeDecompressed(); } >> 104 | void updateHashWithValue(size_t, SipHash &) const override { throwMustBeDecompressed(); } >> 105 | void computeHashInto(size_t, size_t, uint32_t *, bool) const override { throwMustBeDecompressed(); } >> 106 | void updateHashFast(SipHash &) const override { throwMustBeDecompressed(); } >> 107 | ColumnPtr filter(const Filter &, ssize_t) const override { throwMustBeDecompressed(); } >> 108 | void filter(const Filter &) override { throwMustBeDecompressed(); } 109 | void expand(const Filter &, bool) override { throwMustBeDecompressed(); } 110 | ColumnPtr permute(const Permutation &, size_t) const override { throwMustBeDecompressed(); } ================================================================================ src/Columns/ColumnDecimal.cpp ================================================================================ --- uncovered block 210-211 --- 208 | return; 209 | } >> 210 | #endif >> 211 | computeHashIntoDecimalImpl(src, n, hash_out, initial); 212 | } 213 | --- uncovered block 272-280 --- 270 | 271 | if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Unstable) >> 272 | try_sort = trySort(res.begin(), res.end(), comparator_ascending); 273 | else if ( 274 | direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Stable) 275 | try_sort = trySort(res.begin(), res.end(), comparator_ascending_stable); >> 276 | else if ( >> 277 | direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Unstable) >> 278 | try_sort = trySort(res.begin(), res.end(), comparator_descending); 279 | else >> 280 | try_sort = trySort(res.begin(), res.end(), comparator_descending_stable); 281 | 282 | if (try_sort) --- uncovered block 379-379 --- 377 | else 378 | { >> 379 | this->updatePermutationImpl(limit, res, equal_ranges, comparator_descending_stable, equals_comparator, sort, partial_sort); 380 | } 381 | } --- uncovered block 465-471 --- 463 | 464 | if (start + length > src_vec.data.size()) >> 465 | throw Exception( >> 466 | ErrorCodes::PARAMETER_OUT_OF_BOUND, >> 467 | "Parameters start = {}, length = {} are out of bound " >> 468 | "in ColumnDecimal::insertRangeFrom method (data.size() = {}).", >> 469 | toString(start), >> 470 | toString(length), >> 471 | toString(src_vec.data.size())); 472 | 473 | size_t old_size = data.size(); --- uncovered block 484-485 --- 482 | size_t size = data.size(); 483 | if (size != filt.size()) >> 484 | throw Exception( >> 485 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); 486 | 487 | auto res = this->create(0, scale); --- uncovered block 548-549 --- 546 | size_t size = data.size(); 547 | if (size != filt.size()) >> 548 | throw Exception( >> 549 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); 550 | 551 | const UInt8 * filt_pos = filt.data(); --- uncovered block 659-667 --- 657 | 658 | if (!compressed) >> 659 | return ColumnCompressed::wrap(this->getPtr()); 660 | >> 661 | const size_t compressed_size = compressed->size(); >> 662 | return ColumnCompressed::create( >> 663 | data_size, >> 664 | compressed_size, >> 665 | [my_compressed = std::move(compressed), column_size = data_size, my_scale = this->scale] 666 | { >> 667 | auto res = ColumnDecimal::create(column_size, my_scale); 668 | ColumnCompressed::decompressBuffer( 669 | my_compressed->data(), res->getData().data(), my_compressed->size(), column_size * sizeof(T)); ================================================================================ src/Columns/ColumnDynamic.h ================================================================================ --- uncovered block 206-206 --- 204 | void computeHashInto(size_t row_begin, size_t row_end, uint32_t * hash_out, bool initial) const override 205 | { >> 206 | variant_column_ptr->computeHashInto(row_begin, row_end, hash_out, initial); 207 | } 208 | ================================================================================ src/Columns/ColumnFixedString.cpp ================================================================================ --- uncovered block 188-189 --- 186 | return; 187 | } >> 188 | #endif >> 189 | computeHashIntoFixedStringImpl(src, n, n_rows, hash_out, initial); 190 | } 191 | --- uncovered block 283-284 --- 281 | limit, res, equal_ranges, ComparatorDescendingUnstable(*this), comparator_equal, DefaultSort(), DefaultPartialSort()); 282 | else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable) >> 283 | updatePermutationImpl( >> 284 | limit, res, equal_ranges, ComparatorDescendingStable(*this), comparator_equal, DefaultSort(), DefaultPartialSort()); 285 | } 286 | --- uncovered block 315-321 --- 313 | 314 | if (start + length > src_concrete.size()) >> 315 | throw Exception( >> 316 | ErrorCodes::PARAMETER_OUT_OF_BOUND, >> 317 | "Parameters start = {}, length = {} are out of bound " >> 318 | "in ColumnFixedString::insertRangeFrom method (size() = {}).", >> 319 | toString(start), >> 320 | toString(length), >> 321 | toString(src_concrete.size())); 322 | 323 | size_t old_size = chars.size(); --- uncovered block 332-333 --- 330 | size_t col_size = size(); 331 | if (col_size != filt.size()) >> 332 | throw Exception( >> 333 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), col_size); 334 | 335 | auto res = ColumnFixedString::create(n); --- uncovered block 402-403 --- 400 | size_t col_size = size(); 401 | if (col_size != filt.size()) >> 402 | throw Exception( >> 403 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), col_size); 404 | 405 | const UInt8 * filt_pos = filt.data(); --- uncovered block 579-591 --- 577 | return ColumnCompressed::wrap(this->getPtr()); 578 | >> 579 | const size_t column_size = size(); >> 580 | const size_t compressed_size = compressed->size(); >> 581 | return ColumnCompressed::create( >> 582 | column_size, >> 583 | compressed_size, >> 584 | [my_compressed = std::move(compressed), column_size, my_n = n] 585 | { >> 586 | size_t chars_size = my_n * column_size; >> 587 | auto res = ColumnFixedString::create(my_n); >> 588 | res->getChars().resize(chars_size); >> 589 | ColumnCompressed::decompressBuffer(my_compressed->data(), res->getChars().data(), my_compressed->size(), chars_size); >> 590 | return res; >> 591 | }); 592 | } 593 | ================================================================================ src/Columns/ColumnFunction.cpp ================================================================================ --- uncovered block 322-344 --- 320 | void ColumnFunction::computeHashInto(size_t row_begin, size_t row_end, uint32_t * hash_out, bool initial) const 321 | { >> 322 | const size_t n = row_end - row_begin; 323 | >> 324 | if (captured_columns.empty()) 325 | { 326 | /// No captures: matches the former `getWeakHash32` (all bits set). >> 327 | if (initial) >> 328 | for (size_t i = 0; i < n; ++i) >> 329 | hash_out[i] = WEAK_HASH32_INITIAL_VALUE; 330 | else >> 331 | for (size_t i = 0; i < n; ++i) >> 332 | hash_out[i] = combineWeakHash32(WEAK_HASH32_INITIAL_VALUE, hash_out[i]); >> 333 | return; 334 | } 335 | >> 336 | if (initial) 337 | { 338 | /// Seed with `WEAK_HASH32_INITIAL_VALUE` and combine every capture, matching the 339 | /// former `WeakHash32` + `getWeakHash32` chain for `ColumnFunction`. >> 340 | for (size_t i = 0; i < n; ++i) >> 341 | hash_out[i] = WEAK_HASH32_INITIAL_VALUE; >> 342 | for (const auto & column : captured_columns) >> 343 | column.column->computeHashInto(row_begin, row_end, hash_out, false); >> 344 | return; 345 | } 346 | --- uncovered block 352-356 --- 350 | /// a materialized `ColumnFunction` and a `ColumnConst(ColumnFunction)` of the same value 351 | /// compose identically. See IColumn::computeHashInto and ColumnTuple::computeHashInto. >> 352 | PaddedPODArray function_hash(n, WEAK_HASH32_INITIAL_VALUE); >> 353 | for (const auto & column : captured_columns) >> 354 | column.column->computeHashInto(row_begin, row_end, function_hash.data(), false); >> 355 | for (size_t i = 0; i < n; ++i) >> 356 | hash_out[i] = combineWeakHash32(function_hash[i], hash_out[i]); 357 | } 358 | ================================================================================ src/Columns/ColumnLowCardinality.cpp ================================================================================ --- uncovered block 326-326 --- 324 | void ColumnLowCardinality::skipSerializedInArena(ReadBuffer & in) const 325 | { >> 326 | getDictionary().skipSerializedInArena(in); 327 | } 328 | ================================================================================ src/Columns/ColumnNullable.cpp ================================================================================ --- uncovered block 1027-1027 --- 1025 | "Sizes of nested column and null map of Nullable column are not equal (null map size = {}, nested column size = {})", 1026 | null_map->size(), >> 1027 | getNestedColumn().size()); 1028 | } 1029 | --- uncovered block 1034-1034 --- 1032 | { 1033 | if (empty()) >> 1034 | return cloneEmpty(); 1035 | 1036 | ColumnPtr new_values; ================================================================================ src/Columns/ColumnObject.cpp ================================================================================ --- uncovered block 1174-1193 --- 1172 | /// typed paths → dynamic paths → shared data order. `shared_data` always exists, so the 1173 | /// buffer is always seeded (no empty-object special case needed). >> 1174 | auto computeFinalizedInto = [&](uint32_t * out) 1175 | { >> 1176 | bool first = true; >> 1177 | for (const auto & [_, column] : typed_paths) 1178 | { >> 1179 | column->computeHashInto(row_begin, row_end, out, first); >> 1180 | first = false; 1181 | } >> 1182 | for (const auto & [_, column] : dynamic_paths_ptrs) 1183 | { >> 1184 | column->computeHashInto(row_begin, row_end, out, first); >> 1185 | first = false; 1186 | } >> 1187 | shared_data->computeHashInto(row_begin, row_end, out, first); 1188 | }; 1189 | >> 1190 | if (initial) 1191 | { >> 1192 | computeFinalizedInto(hash_out); >> 1193 | return; 1194 | } 1195 | --- uncovered block 1201-1205 --- 1199 | /// representation-independent: a materialized `Object` and a `ColumnConst(Object)` of the 1200 | /// same value compose identically. See IColumn::computeHashInto and ColumnTuple::computeHashInto. >> 1201 | const size_t n = row_end - row_begin; >> 1202 | PaddedPODArray object_hash(n); >> 1203 | computeFinalizedInto(object_hash.data()); >> 1204 | for (size_t i = 0; i < n; ++i) >> 1205 | hash_out[i] = combineWeakHash32(object_hash[i], hash_out[i]); 1206 | } 1207 | ================================================================================ src/Columns/ColumnQBit.h ================================================================================ --- uncovered block 127-132 --- 125 | tuple->deserializeAndInsertFromArena(in, settings); 126 | } >> 127 | void skipSerializedInArena(ReadBuffer & in) const override { tuple->skipSerializedInArena(in); } 128 | void updateHashWithValue(size_t n, SipHash & hash) const override { tuple->updateHashWithValue(n, hash); } 129 | void updateHashFast(SipHash & hash) const override { tuple->updateHashFast(hash); } 130 | void computeHashInto(size_t row_begin, size_t row_end, uint32_t * hash_out, bool initial) const override 131 | { >> 132 | tuple->computeHashInto(row_begin, row_end, hash_out, initial); 133 | } 134 | ================================================================================ src/Columns/ColumnReplicated.cpp ================================================================================ --- uncovered block 522-522 --- 520 | void ColumnReplicated::updateHashWithValue(size_t n, SipHash & hash) const 521 | { >> 522 | nested_column->updateHashWithValue(indexes.getIndexAt(n), hash); 523 | } 524 | ================================================================================ src/Columns/ColumnSparse.cpp ================================================================================ --- uncovered block 774-774 --- 772 | void ColumnSparse::updateHashWithValue(size_t n, SipHash & hash) const 773 | { >> 774 | values->updateHashWithValue(getValueIndex(n), hash); 775 | } 776 | ================================================================================ src/Columns/ColumnString.cpp ================================================================================ --- uncovered block 38-42 --- 36 | /// This will also prevent possible overflow in offset. 37 | if (last_offset != chars.size()) >> 38 | throw Exception( 39 | ErrorCodes::LOGICAL_ERROR, >> 40 | "String offsets has data inconsistent with chars array. Last offset: {}, array length: {}", >> 41 | last_offset, >> 42 | chars.size()); 43 | } 44 | --- uncovered block 260-260 --- 258 | { 259 | if (empty()) >> 260 | return; 261 | 262 | size_t rows = size(); --- uncovered block 484-485 --- 482 | limit, res, equal_ranges, ComparatorDescendingUnstable(*this), comparator_equal, DefaultSort(), DefaultPartialSort()); 483 | else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable) >> 484 | updatePermutationImpl( >> 485 | limit, res, equal_ranges, ComparatorDescendingStable(*this), comparator_equal, DefaultSort(), DefaultPartialSort()); 486 | } 487 | --- uncovered block 503-503 --- 501 | getPermutationImpl(limit, res, ComparatorCollationDescendingUnstable(*this, &collator), DefaultSort(), DefaultPartialSort()); 502 | else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable) >> 503 | getPermutationImpl(limit, res, ComparatorCollationDescendingStable(*this, &collator), DefaultSort(), DefaultPartialSort()); 504 | } 505 | --- uncovered block 819-823 --- 817 | Offset last_offset = offsets.empty() ? 0 : offsets.back(); 818 | if (last_offset != chars.size()) >> 819 | throw Exception( 820 | ErrorCodes::LOGICAL_ERROR, >> 821 | "ColumnString validation failed: size mismatch (internal logical error) {} != {}", >> 822 | last_offset, >> 823 | chars.size()); 824 | } 825 | ================================================================================ src/Columns/ColumnTuple.cpp ================================================================================ --- uncovered block 425-431 --- 423 | { 424 | /// Empty tuple: matches the former `getWeakHash32` (all bits set). >> 425 | if (initial) >> 426 | for (size_t i = 0; i < n; ++i) >> 427 | hash_out[i] = WEAK_HASH32_INITIAL_VALUE; 428 | else >> 429 | for (size_t i = 0; i < n; ++i) >> 430 | hash_out[i] = combineWeakHash32(WEAK_HASH32_INITIAL_VALUE, hash_out[i]); >> 431 | return; 432 | } 433 | ================================================================================ src/Columns/ColumnVariant.cpp ================================================================================ --- uncovered block 943-970 --- 941 | void ColumnVariant::computeHashInto(size_t row_begin, size_t row_end, uint32_t * hash_out, bool initial) const 942 | { >> 943 | const auto & local_discriminators_data = getLocalDiscriminators(); >> 944 | const auto & offsets_data = getOffsets(); 945 | 946 | /// Optimization for case when there is only 1 non-empty variant and no NULLs: 947 | /// the per-row hash is just the hash of that variant. >> 948 | if (auto non_empty_local_discr = getLocalDiscriminatorOfOneNoneEmptyVariantNoNulls()) 949 | { >> 950 | variants[*non_empty_local_discr]->computeHashInto(row_begin, row_end, hash_out, initial); >> 951 | return; 952 | } 953 | 954 | /// Calculate per-row hash for all variants once, then gather by discriminator. 955 | /// NULL rows contribute a constant (0), distinct from any variant value. >> 956 | std::vector> nested_hashes(variants.size()); // STYLE_CHECK_ALLOW_STD_CONTAINERS >> 957 | for (size_t v = 0; v < variants.size(); ++v) 958 | { >> 959 | const size_t variant_size = variants[v]->size(); >> 960 | nested_hashes[v].resize(variant_size); >> 961 | if (variant_size) >> 962 | variants[v]->computeHashInto(0, variant_size, nested_hashes[v].data(), true); 963 | } 964 | >> 965 | for (size_t i = row_begin; i < row_end; ++i) 966 | { >> 967 | const Discriminator discr = local_discriminators_data[i]; >> 968 | const uint32_t value = discr == NULL_DISCRIMINATOR ? 0 : nested_hashes[discr][offsets_data[i]]; >> 969 | uint32_t & out = hash_out[i - row_begin]; >> 970 | out = initial ? value : combineWeakHash32(value, out); 971 | } 972 | } ================================================================================ src/Columns/ColumnVector.cpp ================================================================================ --- uncovered block 474-474 --- 472 | try_sort = trySort(res.begin(), res.end(), greater(*this, nan_direction_hint)); 473 | else >> 474 | try_sort = trySort(res.begin(), res.end(), greater_stable(*this, nan_direction_hint)); 475 | 476 | if (try_sort) --- uncovered block 680-686 --- 678 | 679 | if (start + length > src_vec.data.size()) >> 680 | throw Exception( >> 681 | ErrorCodes::PARAMETER_OUT_OF_BOUND, >> 682 | "Parameters start = {}, length = {} are out of bound " >> 683 | "in ColumnVector::insertRangeFrom method (data.size() = {}).", >> 684 | toString(start), >> 685 | toString(length), >> 686 | toString(src_vec.data.size())); 687 | 688 | size_t old_size = data.size(); --- uncovered block 896-897 --- 894 | size_t size = data.size(); 895 | if (size != filt.size()) >> 896 | throw Exception( >> 897 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); 898 | 899 | auto res = this->create(); --- uncovered block 947-948 --- 945 | 946 | if (size != filter_size) >> 947 | throw Exception( >> 948 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filter_size, size); 949 | 950 | const UInt8 * filt_pos = filt.data(); --- uncovered block 990-991 --- 988 | size_t size = data.size(); 989 | if (size != filt.size()) >> 990 | throw Exception( >> 991 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); 992 | 993 | const UInt8 * filt_pos = filt.data(); --- uncovered block 1076-1077 --- 1074 | const size_t size = data.size(); 1075 | if (size != offsets.size()) >> 1076 | throw Exception( >> 1077 | ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of offsets {} doesn't match size of column {}", offsets.size(), size); 1078 | 1079 | if (size == 0 || offsets.back() == 0) --- uncovered block 1193-1198 --- 1191 | { 1192 | if (offsets.size() + shift != size()) >> 1193 | throw Exception( 1194 | ErrorCodes::LOGICAL_ERROR, >> 1195 | "Incompatible sizes of offsets ({}), shift ({}) and size of column {}", >> 1196 | offsets.size(), >> 1197 | shift, >> 1198 | size()); 1199 | 1200 | auto res = this->create(); ================================================================================ src/Columns/IColumnUnique.h ================================================================================ --- uncovered block 171-176 --- 169 | VectorWithMemoryTracking scatter(size_t, const IColumn::Selector &) const override 170 | { >> 171 | throwNotImplementedForColumnUnique("scatter"); 172 | } 173 | 174 | void computeHashInto(size_t /*row_begin*/, size_t /*row_end*/, uint32_t * /*hash_out*/, bool /*initial*/) const override 175 | { >> 176 | throwNotImplementedForColumnUnique("computeHashInto"); 177 | } 178 | ================================================================================ src/Common/MapToRange.cpp ================================================================================ --- uncovered block 33-46 --- 31 | return; 32 | } >> 33 | #endif >> 34 | mapToRangeImplU64(hashes, n, range_size, result); 35 | } 36 | 37 | void mapToRange(const UInt32 * hashes, size_t n, UInt32 range_size, UInt32 * result) 38 | { >> 39 | #if USE_MULTITARGET_CODE >> 40 | if (isArchSupported(TargetArch::x86_64_v4)) 41 | { >> 42 | mapToRangeImplU32_x86_64_v4(hashes, n, range_size, result); >> 43 | return; 44 | } >> 45 | #endif >> 46 | mapToRangeImplU32(hashes, n, range_size, result); 47 | } 48 | === Lost Baseline Coverage: 12 lines === ================================================================================ src/Columns/ColumnArray.cpp ================================================================================ --- lost coverage block 1283-1285 --- 1281 | else if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Stable) 1282 | updatePermutationImpl(limit, res, equal_ranges, ComparatorAscendingStable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort()); >> 1283 | else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Unstable) 1284 | updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingUnstable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort()); >> 1285 | else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable) 1286 | updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingStable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort()); 1287 | } ================================================================================ src/Columns/ColumnNullable.cpp ================================================================================ --- lost coverage block 51-51 --- 49 | return getNestedColumn().getDataAt(n); 50 | >> 51 | throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method getDataAt is not supported for {} in case if value is NULL", getName()); 52 | } 53 | ================================================================================ src/Columns/ColumnObject.cpp ================================================================================ --- lost coverage block 1623-1623 --- 1621 | { 1622 | if (source_columns.empty()) >> 1623 | return; 1624 | 1625 | /// Dynamic paths of source Object columns may differ. ================================================================================ src/Columns/ColumnReplicated.cpp ================================================================================ --- lost coverage block 432-432 --- 430 | else if (direction == PermutationSortDirection::Descending && stability == PermutationSortStability::Unstable) 431 | updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingUnstable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort()); >> 432 | else if (direction == PermutationSortDirection::Descending && stability == PermutationSortStability::Stable) 433 | updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingStable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort()); 434 | } ================================================================================ src/Columns/ColumnSparse.cpp ================================================================================ --- lost coverage block 70-75 --- 68 | return ColumnSparse::create(values->cloneEmpty()); 69 | >> 70 | if (new_size >= _size) 71 | return ColumnSparse::create(IColumn::mutate(values), IColumn::mutate(offsets), new_size); 72 | >> 73 | auto res = ColumnSparse::create(values->cloneEmpty()); >> 74 | res->insertRangeFrom(*this, 0, new_size); >> 75 | return res; 76 | } 77 | ================================================================================ src/Columns/ColumnTuple.cpp ================================================================================ --- lost coverage block 426-426 --- 424 | /// Empty tuple: matches the former `getWeakHash32` (all bits set). 425 | if (initial) >> 426 | for (size_t i = 0; i < n; ++i) 427 | hash_out[i] = WEAK_HASH32_INITIAL_VALUE; 428 | else ================================================================================ src/Columns/ColumnVector.cpp ================================================================================ --- lost coverage block 474-474 --- 472 | try_sort = trySort(res.begin(), res.end(), greater(*this, nan_direction_hint)); 473 | else >> 474 | try_sort = trySort(res.begin(), res.end(), greater_stable(*this, nan_direction_hint)); 475 | 476 | if (try_sort) ================================================================================ src/Interpreters/JoinUtils.cpp ================================================================================ --- lost coverage block 601-601 --- 599 | if (likely(isPowerOf2(num_shards))) 600 | return scatterBlockByHashPow2(key_columns_names, block, num_shards); >> 601 | return scatterBlockByHashGeneric(key_columns_names, block, num_shards); 602 | } 603 | WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set --- Coverage counts --- Lines : baseline 787,154/930,721 -> current 787,849/931,073 (delta +695 / +352) Functions : baseline 888,045/961,686 -> current 888,092/961,697 (delta +47 / +11) Branches : baseline 257,949/334,138 -> current 258,256/334,292 (delta +307 / +154)