75.49% (465/616) Uncovered changed code (with context): ================================================================================ src/AggregateFunctions/AggregateFunctionSum.h ================================================================================ --- uncovered block 151-152 --- 149 | if (isArchSupported(TargetArch::x86_64_v3)) 150 | { >> 151 | addManyImpl_x86_64_v3(ptr, start, end); >> 152 | return; 153 | } 154 | #endif --- uncovered block 256-257 --- 254 | if (isArchSupported(TargetArch::x86_64_v3)) 255 | { >> 256 | addManyConditionalInternalImpl_x86_64_v3(ptr, condition_map, start, end); >> 257 | return; 258 | } 259 | #endif ================================================================================ src/Columns/ColumnVector.cpp ================================================================================ --- uncovered block 337-337 --- 335 | return; 336 | } >> 337 | if (isArchSupported(TargetArch::x86_64_v3)) 338 | { 339 | compareColumnImpl_x86_64_v3(data, value, compare_results, direction, nan_direction_hint); --- uncovered block 339-340 --- 337 | if (isArchSupported(TargetArch::x86_64_v3)) 338 | { >> 339 | compareColumnImpl_x86_64_v3(data, value, compare_results, direction, nan_direction_hint); >> 340 | return; 341 | } 342 | #endif --- uncovered block 342-343 --- 340 | return; 341 | } >> 342 | #endif >> 343 | compareColumnImpl(data, value, compare_results, direction, nan_direction_hint); 344 | } 345 | --- uncovered block 1034-1035 --- 1032 | replicateImpl_x86_64_v4(data.data(), size, window_size, offsets, res->getData().data()); 1033 | else if (isArchSupported(TargetArch::x86_64_v3)) >> 1034 | if (use_window) >> 1035 | replicateImpl_x86_64_v3(data.data(), size, window_size, offsets, res->getData().data()); 1036 | else 1037 | replicateImpl_x86_64_v3(data.data(), size, window_size, offsets, res->getData().data()); --- uncovered block 1037-1037 --- 1035 | replicateImpl_x86_64_v3(data.data(), size, window_size, offsets, res->getData().data()); 1036 | else >> 1037 | replicateImpl_x86_64_v3(data.data(), size, window_size, offsets, res->getData().data()); 1038 | else 1039 | #endif ================================================================================ src/Columns/FilterDescription.cpp ================================================================================ --- uncovered block 46-46 --- 44 | return true; 45 | } >> 46 | if (isArchSupported(TargetArch::x86_64_v3)) 47 | { 48 | convertColumnToBoolImpl_x86_64_v3(data, res); --- uncovered block 48-49 --- 46 | if (isArchSupported(TargetArch::x86_64_v3)) 47 | { >> 48 | convertColumnToBoolImpl_x86_64_v3(data, res); >> 49 | return true; 50 | } 51 | #endif --- uncovered block 51-52 --- 49 | return true; 50 | } >> 51 | #endif >> 52 | convertColumnToBoolImpl(data, res); 53 | 54 | return true; ================================================================================ src/Common/Base58.cpp ================================================================================ --- uncovered block 142-143 --- 140 | return TargetSpecific::x86_64_v3::encodeBase58_32(reinterpret_cast(src), reinterpret_cast(dst)); 141 | else >> 142 | #endif >> 143 | return TargetSpecific::Default::encodeBase58_32(reinterpret_cast(src), reinterpret_cast(dst)); 144 | } 145 | --- uncovered block 152-153 --- 150 | return TargetSpecific::x86_64_v3::encodeBase58_64(reinterpret_cast(src), reinterpret_cast(dst)); 151 | else >> 152 | #endif >> 153 | return TargetSpecific::Default::encodeBase58_64(reinterpret_cast(src), reinterpret_cast(dst)); 154 | } 155 | ================================================================================ src/Common/EnvironmentChecks.cpp ================================================================================ --- uncovered block 32-32 --- 30 | auto instructionFailToString(InstructionFail fail) 31 | { >> 32 | switch (fail) 33 | { 34 | #define ret(x) return std::make_tuple(STDERR_FILENO, x, sizeof(x) - 1) --- uncovered block 34-53 --- 32 | switch (fail) 33 | { >> 34 | #define ret(x) return std::make_tuple(STDERR_FILENO, x, sizeof(x) - 1) >> 35 | case InstructionFail::NONE: >> 36 | ret("NONE"); >> 37 | case InstructionFail::SSE3: >> 38 | ret("SSE3"); >> 39 | case InstructionFail::SSSE3: >> 40 | ret("SSSE3"); >> 41 | case InstructionFail::SSE4_1: >> 42 | ret("SSE4.1"); >> 43 | case InstructionFail::SSE4_2: >> 44 | ret("SSE4.2"); >> 45 | case InstructionFail::POPCNT: >> 46 | ret("POPCNT"); >> 47 | case InstructionFail::AVX: >> 48 | ret("AVX"); >> 49 | case InstructionFail::AVX2: >> 50 | ret("AVX2"); >> 51 | case InstructionFail::AVX512: >> 52 | ret("AVX512"); >> 53 | #undef ret 54 | } 55 | } --- uncovered block 62-62 --- 60 | [[noreturn]] void sigIllCheckHandler(int, siginfo_t *, void *) 61 | { >> 62 | siglongjmp(jmpbuf, 1); 63 | } 64 | --- uncovered block 124-129 --- 122 | 123 | /// Macros to avoid using strlen(), since it may fail if SSE is not supported. >> 124 | #define writeError(data) do \ >> 125 | { \ >> 126 | static_assert(__builtin_constant_p(data)); \ >> 127 | if (!writeRetry(STDERR_FILENO, data, sizeof(data) - 1)) \ >> 128 | _Exit(1); \ >> 129 | } while (false) 130 | 131 | /// Check SSE and others instructions availability. Calls exit on fail. --- uncovered block 148-149 --- 146 | /// But this is not the case because it's compiler builtin and is executed at compile time. 147 | >> 148 | writeError("Can not set signal handler\n"); >> 149 | _Exit(1); 150 | } 151 | --- uncovered block 156-160 --- 154 | if (sigsetjmp(jmpbuf, 1)) 155 | { >> 156 | writeError("Instruction check fail. The CPU does not support "); >> 157 | if (!std::apply(writeRetry, instructionFailToString(fail))) >> 158 | _Exit(1); >> 159 | writeError(" instruction set.\n"); >> 160 | _Exit(1); 161 | } 162 | --- uncovered block 167-168 --- 165 | if (sigaction(signal, &sa_old, nullptr)) 166 | { >> 167 | writeError("Can not set signal handler\n"); >> 168 | _Exit(1); 169 | } 170 | } ================================================================================ src/Common/StringUtils.cpp ================================================================================ --- uncovered block 84-87 --- 82 | if (isArchSupported(DB::TargetArch::x86_64_v3)) 83 | return TargetSpecific::x86_64_v3::isAllASCII(data, size); >> 84 | if (isArchSupported(DB::TargetArch::x86_64_v2)) >> 85 | return TargetSpecific::x86_64_v2::isAllASCII(data, size); >> 86 | #endif >> 87 | return TargetSpecific::Default::isAllASCII(data, size); 88 | } 89 | ================================================================================ src/Common/TargetSpecific.h ================================================================================ --- uncovered block 304-304 --- 302 | X86_64_V3_FUNCTION_SPECIFIC_ATTRIBUTE \ 303 | name##_x86_64_v3 \ >> 304 | FUNCTION_BODY \ 305 | \ 306 | FUNCTION_HEADER \ --- uncovered block 309-309 --- 307 | \ 308 | name \ >> 309 | FUNCTION_BODY \ 310 | 311 | #define MULTITARGET_FUNCTION_X86_V3(FUNCTION_HEADER, name, FUNCTION_BODY) \ --- uncovered block 321-321 --- 319 | \ 320 | name \ >> 321 | FUNCTION_BODY \ 322 | 323 | ================================================================================ src/Common/iota.cpp ================================================================================ --- uncovered block 42-43 --- 40 | if (isArchSupported(TargetArch::x86_64_v3)) 41 | return iotaWithStepImpl_x86_64_v3(begin, count, first_value, step); >> 42 | #endif >> 43 | return iotaWithStepImpl(begin, count, first_value, step); 44 | } 45 | ================================================================================ src/Compression/CompressionCodecT64.cpp ================================================================================ --- uncovered block 414-414 --- 412 | return; 413 | } >> 414 | if (isArchSupported(TargetArch::x86_64_v3)) 415 | { 416 | transposeImpl_x86_64_v3(src, dst, num_bits, tail); --- uncovered block 416-417 --- 414 | if (isArchSupported(TargetArch::x86_64_v3)) 415 | { >> 416 | transposeImpl_x86_64_v3(src, dst, num_bits, tail); >> 417 | return; 418 | } 419 | #endif --- uncovered block 419-419 --- 417 | return; 418 | } >> 419 | #endif 420 | { 421 | transposeImpl(src, dst, num_bits, tail); --- uncovered block 421-421 --- 419 | #endif 420 | { >> 421 | transposeImpl(src, dst, num_bits, tail); 422 | } 423 | } --- uncovered block 467-468 --- 465 | if (isArchSupported(TargetArch::x86_64_v3)) 466 | { >> 467 | reverseTransposeImpl_x86_64_v3(src, buf, num_bits, tail); >> 468 | return; 469 | } 470 | #endif ================================================================================ src/Core/DecimalComparison.h ================================================================================ --- uncovered block 308-308 --- 306 | } 307 | >> 308 | if (isArchSupported(TargetArch::x86_64_v3)) 309 | { 310 | vectorConstantImpl_x86_64_v3(a, b, c, scale); --- uncovered block 310-311 --- 308 | if (isArchSupported(TargetArch::x86_64_v3)) 309 | { >> 310 | vectorConstantImpl_x86_64_v3(a, b, c, scale); >> 311 | return; 312 | } 313 | #endif --- uncovered block 313-313 --- 311 | return; 312 | } >> 313 | #endif 314 | 315 | vectorConstantImpl(a, b, c, scale); --- uncovered block 315-315 --- 313 | #endif 314 | >> 315 | vectorConstantImpl(a, b, c, scale); 316 | } 317 | ================================================================================ src/Functions/FunctionUnaryArithmetic.h ================================================================================ --- uncovered block 63-63 --- 61 | } 62 | >> 63 | if (isArchSupported(TargetArch::x86_64_v3)) 64 | { 65 | vectorImpl_x86_64_v3(a, c); --- uncovered block 65-66 --- 63 | if (isArchSupported(TargetArch::x86_64_v3)) 64 | { >> 65 | vectorImpl_x86_64_v3(a, c); >> 66 | return; 67 | } 68 | #endif --- uncovered block 68-68 --- 66 | return; 67 | } >> 68 | #endif 69 | 70 | vectorImpl(a, c); --- uncovered block 70-70 --- 68 | #endif 69 | >> 70 | vectorImpl(a, c); 71 | } 72 | --- uncovered block 102-102 --- 100 | } 101 | >> 102 | if (isArchSupported(TargetArch::x86_64_v3)) 103 | { 104 | vectorImpl_x86_64_v3(a, c); --- uncovered block 104-105 --- 102 | if (isArchSupported(TargetArch::x86_64_v3)) 103 | { >> 104 | vectorImpl_x86_64_v3(a, c); >> 105 | return; 106 | } 107 | #endif --- uncovered block 107-107 --- 105 | return; 106 | } >> 107 | #endif 108 | 109 | vectorImpl(a, c); --- uncovered block 109-109 --- 107 | #endif 108 | >> 109 | vectorImpl(a, c); 110 | } 111 | }; --- uncovered block 135-135 --- 133 | } 134 | >> 135 | if (isArchSupported(TargetArch::x86_64_v3)) 136 | { 137 | return vectorImpl_x86_64_v3(start, end); --- uncovered block 137-137 --- 135 | if (isArchSupported(TargetArch::x86_64_v3)) 136 | { >> 137 | return vectorImpl_x86_64_v3(start, end); 138 | } 139 | #endif --- uncovered block 139-139 --- 137 | return vectorImpl_x86_64_v3(start, end); 138 | } >> 139 | #endif 140 | 141 | return vectorImpl(start, end); --- uncovered block 141-141 --- 139 | #endif 140 | >> 141 | return vectorImpl(start, end); 142 | } 143 | }; ================================================================================ src/Functions/FunctionsComparison.h ================================================================================ --- uncovered block 179-180 --- 177 | if (isArchSupported(TargetArch::x86_64_v3)) 178 | { >> 179 | vectorVectorImpl_x86_64_v3(a, b, c); >> 180 | return; 181 | } 182 | #endif --- uncovered block 216-217 --- 214 | if (isArchSupported(TargetArch::x86_64_v3)) 215 | { >> 216 | vectorConstantImpl_x86_64_v3(a, b, c); >> 217 | return; 218 | } 219 | #endif ================================================================================ src/Functions/FunctionsConsistentHashing.h ================================================================================ --- uncovered block 110-110 --- 108 | 109 | if (buckets_field.getType() == Field::Types::Int64) >> 110 | num_buckets = checkBucketsRange(buckets_field.safeGet()); 111 | else if (buckets_field.getType() == Field::Types::UInt64) 112 | num_buckets = checkBucketsRange(buckets_field.safeGet()); --- uncovered block 114-116 --- 112 | num_buckets = checkBucketsRange(buckets_field.safeGet()); 113 | else >> 114 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, >> 115 | "Illegal type {} of the second argument of function {}", >> 116 | buckets_field.getTypeName(), getName()); 117 | 118 | const auto & hash_col = arguments[0].column; ================================================================================ src/Functions/FunctionsLogical.cpp ================================================================================ --- uncovered block 429-433 --- 427 | if (isArchSupported(TargetArch::x86_64_v3)) 428 | { >> 429 | if (!use_result_data_as_input) >> 430 | doBatchedApplyAVX2(in, result_data.data(), result_data.size()); >> 431 | while (!in.empty()) >> 432 | doBatchedApplyAVX2(in, result_data.data(), result_data.size()); >> 433 | return; 434 | } 435 | #endif --- uncovered block 486-486 --- 484 | static void doBatchedApplyAVX2(Columns & in, Result * __restrict result_data, size_t size) X86_64_V3_FUNCTION_SPECIFIC_ATTRIBUTE 485 | { >> 486 | BATCH_BODY(doBatchedApplyAVX2) 487 | } 488 | #endif --- uncovered block 580-581 --- 578 | if (isArchSupported(TargetArch::x86_64_v3)) 579 | { >> 580 | applyImpl_x86_64_v3(x, *column, result); >> 581 | return; 582 | } 583 | #endif ================================================================================ src/Functions/GatherUtils/sliceHasImplAnyAll.h ================================================================================ --- uncovered block 917-917 --- 915 | else if constexpr (std::is_same_v> || std::is_same_v>) 916 | { >> 917 | return GatherUtils::TargetSpecific::x86_64_v2::sliceHasImplAnyAllImplInt16(first, second, first_null_map, second_null_map); 918 | } 919 | else if constexpr (std::is_same_v> || std::is_same_v>) --- uncovered block 921-921 --- 919 | else if constexpr (std::is_same_v> || std::is_same_v>) 920 | { >> 921 | return GatherUtils::TargetSpecific::x86_64_v2::sliceHasImplAnyAllImplInt32(first, second, first_null_map, second_null_map); 922 | } 923 | else if constexpr (std::is_same_v> || std::is_same_v>) --- uncovered block 925-925 --- 923 | else if constexpr (std::is_same_v> || std::is_same_v>) 924 | { >> 925 | return GatherUtils::TargetSpecific::x86_64_v2::sliceHasImplAnyAllImplInt64(first, second, first_null_map, second_null_map); 926 | } 927 | } --- uncovered block 929-929 --- 927 | } 928 | } >> 929 | #endif 930 | 931 | return sliceHasImplAnyAllGenericImpl(first, second, first_null_map, second_null_map); ================================================================================ src/Functions/array/arrayDotProduct.cpp ================================================================================ --- uncovered block 287-288 --- 285 | if (isArchSupported(TargetArch::x86_64_v4)) 286 | result_data[row] = dotProductImpl_x86_64_v4(data_x.data() + current_offset, data_y.data() + current_offset, array_size); >> 287 | else if (isArchSupported(TargetArch::x86_64_v3)) >> 288 | result_data[row] = dotProductImpl_x86_64_v3(data_x.data() + current_offset, data_y.data() + current_offset, array_size); 289 | else 290 | #endif --- uncovered block 290-291 --- 288 | result_data[row] = dotProductImpl_x86_64_v3(data_x.data() + current_offset, data_y.data() + current_offset, array_size); 289 | else >> 290 | #endif >> 291 | result_data[row] = dotProductImpl(data_x.data() + current_offset, data_y.data() + current_offset, array_size); 292 | } 293 | else --- uncovered block 374-375 --- 372 | if (isArchSupported(TargetArch::x86_64_v4)) 373 | result[row] = dotProductImpl_x86_64_v4(data_x.data(), data_y.data() + current_offset, array_size); >> 374 | else if (isArchSupported(TargetArch::x86_64_v3)) >> 375 | result[row] = dotProductImpl_x86_64_v3(data_x.data(), data_y.data() + current_offset, array_size); 376 | else 377 | #endif --- uncovered block 377-378 --- 375 | result[row] = dotProductImpl_x86_64_v3(data_x.data(), data_y.data() + current_offset, array_size); 376 | else >> 377 | #endif >> 378 | result[row] = dotProductImpl(data_x.data(), data_y.data() + current_offset, array_size); 379 | } 380 | else ================================================================================ src/Functions/divide/divide.cpp ================================================================================ --- uncovered block 32-32 --- 30 | AVX2::divideImpl(a_pos, b, c_pos, size); 31 | else if (DB::CPU::CPUFlagsCache::have_SSE2) >> 32 | SSE2::divideImpl(a_pos, b, c_pos, size); 33 | #else 34 | Generic::divideImpl(a_pos, b, c_pos, size); ================================================================================ src/Functions/divide/divideImpl.cpp ================================================================================ --- uncovered block 9-9 --- 7 | #define LIBDIVIDE_AVX2 8 | #elif defined(__SSE2__) >> 9 | #define REG_SIZE 16 10 | #define LIBDIVIDE_SSE2 11 | #endif ================================================================================ src/Functions/isNotNull.cpp ================================================================================ --- uncovered block 159-160 --- 157 | return; 158 | } >> 159 | #endif >> 160 | vectorImpl(null_map, res); 161 | } 162 | ================================================================================ src/Functions/modulo.cpp ================================================================================ --- uncovered block 110-110 --- 108 | /// Modulo of division by negative number is the same as the positive number. 109 | if (b < 0) >> 110 | b = static_cast(-b); 111 | 112 | /// Here we failed to make the SSE variant from libdivide give an advantage. ================================================================================ src/Storages/MergeTree/MergeTreeRangeReader.cpp ================================================================================ --- uncovered block 820-820 --- 818 | return TargetSpecific::x86_64_v4::numZerosInTail(begin, end); 819 | if (isArchSupported(TargetArch::x86_64_v3)) >> 820 | return TargetSpecific::x86_64_v3::numZerosInTail(begin, end); 821 | #endif 822 | --- uncovered block 829-846 --- 827 | while (end - begin >= 64) 828 | { >> 829 | end -= 64; >> 830 | const auto * pos = end; >> 831 | UInt64 val = >> 832 | static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( >> 833 | _mm_loadu_si128(reinterpret_cast(pos)), >> 834 | zero16))) >> 835 | | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( >> 836 | _mm_loadu_si128(reinterpret_cast(pos + 16)), >> 837 | zero16))) << 16u) >> 838 | | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( >> 839 | _mm_loadu_si128(reinterpret_cast(pos + 32)), >> 840 | zero16))) << 32u) >> 841 | | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( >> 842 | _mm_loadu_si128(reinterpret_cast(pos + 48)), >> 843 | zero16))) << 48u); >> 844 | val = ~val; >> 845 | if (val == 0) >> 846 | count += 64; 847 | else 848 | { --- uncovered block 849-850 --- 847 | else 848 | { >> 849 | count += std::countl_zero(val); >> 850 | return count; 851 | } 852 | } --- uncovered block 886-886 --- 884 | { 885 | --end; >> 886 | ++count; 887 | } 888 | return count; --- uncovered block 1570-1570 --- 1568 | else if (isArchSupported(TargetArch::x86_64_v3)) 1569 | { >> 1570 | TargetSpecific::x86_64_v3::combineFiltersImpl(first_data.begin(), first_data.end(), second_data); 1571 | } 1572 | else --- uncovered block 1577-1577 --- 1575 | for (auto & val : first_data) 1576 | { >> 1577 | if (val) 1578 | { 1579 | val = *second_data; --- uncovered block 1580-1580 --- 1578 | { 1579 | val = *second_data; >> 1580 | ++second_data; 1581 | } 1582 | } === Lost Baseline Coverage: 18 lines === ================================================================================ src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.cpp ================================================================================ --- lost coverage block 165-166 --- 163 | 164 | if (arguments.size() < 2) >> 165 | throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires two or more arguments", >> 166 | name); 167 | 168 | for (const auto & argument : arguments) ================================================================================ src/Common/Base58.cpp ================================================================================ --- lost coverage block 143-143 --- 141 | else 142 | #endif >> 143 | return TargetSpecific::Default::encodeBase58_32(reinterpret_cast(src), reinterpret_cast(dst)); 144 | } 145 | --- lost coverage block 153-153 --- 151 | else 152 | #endif >> 153 | return TargetSpecific::Default::encodeBase58_64(reinterpret_cast(src), reinterpret_cast(dst)); 154 | } 155 | ================================================================================ src/Core/DecimalComparison.h ================================================================================ --- lost coverage block 128-128 --- 126 | shift.b = static_cast(result_type.scaleFactorFor(DecimalUtils::DataTypeDecimalTrait{decimal1->getPrecision(), decimal1->getScale()}, false).value); 127 | } >> 128 | else if (decimal0) 129 | shift.b = static_cast(decimal0->getScaleMultiplier().value); 130 | else if (decimal1) --- lost coverage block 130-130 --- 128 | else if (decimal0) 129 | shift.b = static_cast(decimal0->getScaleMultiplier().value); >> 130 | else if (decimal1) 131 | shift.a = static_cast(decimal1->getScaleMultiplier().value); 132 | --- lost coverage block 313-313 --- 311 | return; 312 | } >> 313 | #endif 314 | 315 | vectorConstantImpl(a, b, c, scale); --- lost coverage block 315-315 --- 313 | #endif 314 | >> 315 | vectorConstantImpl(a, b, c, scale); 316 | } 317 | ================================================================================ src/Functions/FunctionsConsistentHashing.h ================================================================================ --- lost coverage block 110-110 --- 108 | 109 | if (buckets_field.getType() == Field::Types::Int64) >> 110 | num_buckets = checkBucketsRange(buckets_field.safeGet()); 111 | else if (buckets_field.getType() == Field::Types::UInt64) 112 | num_buckets = checkBucketsRange(buckets_field.safeGet()); ================================================================================ src/Functions/FunctionsHashing.h ================================================================================ --- lost coverage block 618-618 --- 616 | static Int32 combineHashes(Int32, Int32) 617 | { >> 618 | throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Hive hash is not combineable for multiple arguments"); 619 | } 620 | --- lost coverage block 644-644 --- 642 | using uint128_t = NAMESPACE_FOR_HASH_FUNCTIONS::uint128_t; 643 | >> 644 | static auto combineHashes(UInt64 h1, UInt64 h2) { return NAMESPACE_FOR_HASH_FUNCTIONS::Fingerprint(uint128_t(h1, h2)); } 645 | static auto apply(const char * s, const size_t len) { return NAMESPACE_FOR_HASH_FUNCTIONS::Fingerprint64(s, len); } 646 | static constexpr bool use_int_hash_for_pods = true; --- lost coverage block 657-658 --- 655 | using uint128_t = NAMESPACE_FOR_HASH_FUNCTIONS::uint128_t; 656 | >> 657 | static auto combineHashes(UInt64 h1, UInt64 h2) { return NAMESPACE_FOR_HASH_FUNCTIONS::Hash128to64(uint128_t(h1, h2)); } >> 658 | static auto apply(const char * s, const size_t len) { return NAMESPACE_FOR_HASH_FUNCTIONS::Hash64(s, len); } 659 | static constexpr bool use_int_hash_for_pods = true; 660 | static constexpr bool return_bigint_instead_of_fixedstring = false; ================================================================================ src/Functions/array/range.cpp ================================================================================ --- lost coverage block 64-66 --- 62 | if (arguments.size() > 3 || arguments.empty()) 63 | { >> 64 | throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, >> 65 | "Function {} needs 1..3 arguments; passed {}.", >> 66 | getName(), arguments.size()); 67 | } 68 | --- lost coverage block 82-83 --- 80 | arg_types.push_back(type_no_nullable); 81 | else >> 82 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", >> 83 | arguments[i]->getName(), getName()); 84 | } 85 | WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set --- Coverage counts --- Lines : baseline 766,143/910,981 -> current 765,455/909,943 (delta -688 / -1,038) Functions : baseline 831,643/904,205 -> current 831,596/914,748 (delta -47 / +10,543) Branches : baseline 249,642/326,198 -> current 249,460/325,752 (delta -182 / -446)