================================================================================ 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: 87.20% (613/703) Uncovered changed code (with context): ================================================================================ base/base/BFloat16.h ================================================================================ --- uncovered block 240-240 --- 238 | constexpr bool operator<=(const BFloat16 & a, const T & b) 239 | { >> 240 | return static_cast>(Float32(a)) <= static_cast>(b); 241 | } 242 | --- uncovered block 286-286 --- 284 | constexpr inline auto operator+(BFloat16 a, T b) 285 | { >> 286 | return static_cast>(Float32(a)) + static_cast>(b); 287 | } 288 | ================================================================================ programs/check-marks/CheckMarks.cpp ================================================================================ --- uncovered block 60-60 --- 58 | int mainEntryClickHouseCheckMarks(int argc, char ** argv) 59 | { >> 60 | boost::program_options::options_description desc("Allowed options"); 61 | desc.add_options() 62 | ("help,h", "produce help message") ================================================================================ programs/checksum-for-compressed-block/ChecksumForCompressedBlock.cpp ================================================================================ --- uncovered block 35-36 --- 33 | std::string flipBit(std::string s, size_t pos) 34 | { >> 35 | s[pos / 8] ^= 1 << pos % 8; >> 36 | return s; 37 | } 38 | --- uncovered block 44-44 --- 42 | int mainEntryClickHouseChecksumForCompressedBlock(int, char **) 43 | { >> 44 | using namespace DB; 45 | ReadBufferFromFileDescriptor in(STDIN_FILENO); 46 | std::string str; ================================================================================ programs/docker-init/docker-init.cpp ================================================================================ --- uncovered block 769-769 --- 767 | int mainEntryClickHouseDockerInit(int argc, char ** argv) 768 | { >> 769 | g_clickhouse_binary = (argc > 0 && argv[0][0] != '\0') ? argv[0] : "clickhouse"; 770 | 771 | bool keeper_mode = false; --- uncovered block 1036-1043 --- 1034 | /// As PID 1, signals without a handler are silently dropped by the kernel. 1035 | { >> 1036 | struct sigaction sa{}; >> 1037 | #pragma clang diagnostic push >> 1038 | #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" >> 1039 | sa.sa_handler = shutdownHandler; >> 1040 | #pragma clang diagnostic pop >> 1041 | sigemptyset(&sa.sa_mask); >> 1042 | sa.sa_flags = SA_RESTART; >> 1043 | sigaction(SIGTERM, &sa, nullptr); 1044 | sigaction(SIGINT, &sa, nullptr); 1045 | } ================================================================================ programs/keeper-data-dumper/KeeperDataDumper.cpp ================================================================================ --- uncovered block 30-30 --- 28 | void dumpMachine(std::shared_ptr> machine) 29 | { >> 30 | auto & storage = machine->getStorageUnsafe(); 31 | std::queue keys; 32 | keys.push("/"); --- uncovered block 58-58 --- 56 | } 57 | } >> 58 | std::cout << std::flush; 59 | } 60 | --- uncovered block 66-66 --- 64 | int mainEntryClickHouseKeeperDataDumper(int argc, char ** argv) 65 | { >> 66 | if (argc != 3) 67 | { 68 | std::cerr << "usage: " << argv[0] << " snapshotpath logpath" << std::endl; ================================================================================ programs/keeper-utils/KeeperUtils.cpp ================================================================================ --- uncovered block 968-968 --- 966 | int mainEntryClickHouseKeeperUtils(int argc, char ** argv) 967 | { >> 968 | namespace po = boost::program_options; 969 | 970 | try ================================================================================ programs/local/LocalServer.cpp ================================================================================ --- uncovered block 224-224 --- 222 | else if (client_exception) 223 | { >> 224 | message = client_exception->message(); 225 | } 226 | ================================================================================ programs/server/Server.cpp ================================================================================ --- uncovered block 1172-1172 --- 1170 | LOG_IMPL(azure_sdk_logger, db_level, poco_level, fmt::runtime(message)); 1171 | }); >> 1172 | #endif 1173 | } 1174 | ================================================================================ programs/su/su.cpp ================================================================================ --- uncovered block 192-192 --- 190 | int mainEntryClickHouseSU(int argc, char ** argv); 191 | int mainEntryClickHouseSU(int argc, char ** argv) >> 192 | try 193 | { 194 | using namespace DB; ================================================================================ programs/zookeeper-dump-tree/ZooKeeperDumpTree.cpp ================================================================================ --- uncovered block 12-12 --- 10 | int mainEntryClickHouseZooKeeperDumpTree(int argc, char ** argv) 11 | { >> 12 | try 13 | { 14 | boost::program_options::options_description desc("Allowed options"); ================================================================================ programs/zookeeper-remove-by-list/ZooKeeperRemoveByList.cpp ================================================================================ --- uncovered block 11-11 --- 9 | int mainEntryClickHouseZooKeeperRemoveByList(int argc, char ** argv); 10 | int mainEntryClickHouseZooKeeperRemoveByList(int argc, char ** argv) >> 11 | try 12 | { 13 | boost::program_options::options_description desc("Allowed options"); ================================================================================ src/AggregateFunctions/AggregateFunctionDistinctDynamicTypes.cpp ================================================================================ --- uncovered block 155-155 --- 153 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}. Expected type Dynamic", argument_types[0]->getName(), name); 154 | >> 155 | return std::make_shared(argument_types); 156 | } 157 | ================================================================================ src/AggregateFunctions/Moments.h ================================================================================ --- uncovered block 662-662 --- 660 | 661 | if (k == n) >> 662 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "There is only one observation in each group"); 663 | 664 | return 1.0 - boost::math::cdf(boost::math::fisher_f(static_cast(k - 1), static_cast(n - k)), f_statistic); ================================================================================ src/AggregateFunctions/QuantileTDigest.h ================================================================================ --- uncovered block 151-185 --- 149 | const size_t batch_size = (centroids.size() + params.max_centroids - 1) / params.max_centroids; // at least 2 150 | >> 151 | auto l = centroids.begin(); >> 152 | auto r = std::next(l); >> 153 | BetterFloat sum = 0; >> 154 | BetterFloat l_mean = static_cast(l->mean); // We have high-precision temporaries for numeric stability >> 155 | BetterFloat l_count = static_cast(l->count); >> 156 | size_t batch_pos = 0; 157 | >> 158 | for (; r != centroids.end(); ++r) 159 | { >> 160 | if (batch_pos < batch_size - 1) 161 | { 162 | /// The left column "eats" the right. Middle of the batch >> 163 | l_count += static_cast(r->count); >> 164 | if (static_cast(r->mean) != l_mean) /// Handling infinities of the same sign well. 165 | { >> 166 | l_mean += static_cast(r->count) * (static_cast(r->mean) - l_mean) / l_count; // Symmetric algo (M1*C1 + M2*C2)/(C1+C2) is numerically better, but slower 167 | } >> 168 | l->mean = static_cast(l_mean); >> 169 | l->count = static_cast(l_count); 170 | batch_pos += 1; 171 | } 172 | else 173 | { 174 | // End of the batch, start the next one >> 175 | if (!std::isnan(l->mean)) /// Skip writing batch result if we compressed something to nan. 176 | { >> 177 | sum += static_cast(l->count); // Not l_count, otherwise actual sum of elements will be different >> 178 | ++l; 179 | } 180 | 181 | /// We skip all the values "eaten" earlier. >> 182 | *l = *r; >> 183 | l_mean = static_cast(l->mean); >> 184 | l_count = static_cast(l->count); >> 185 | batch_pos = 0; 186 | } 187 | } --- uncovered block 323-323 --- 321 | { 322 | if (c.count <= 0 || std::isnan(c.count)) // invalid count breaks compress() >> 323 | throw Exception(ErrorCodes::CANNOT_PARSE_INPUT_ASSERTION_FAILED, "Invalid centroid {}:{}", c.count, std::to_string(c.mean)); 324 | if (!std::isnan(c.mean)) 325 | { ================================================================================ src/Client/ReplxxLineReader.cpp ================================================================================ --- uncovered block 164-167 --- 162 | /// musl defines `stderr` as a recursive macro `(stderr)`, 163 | /// which triggers `-Wdisabled-macro-expansion` when used as a function argument. >> 164 | #pragma clang diagnostic push >> 165 | #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" >> 166 | fmt::print(stderr, "{}", e.what()); >> 167 | #pragma clang diagnostic pop 168 | } 169 | } ================================================================================ src/Columns/tests/gtest_column_sparse.cpp ================================================================================ --- uncovered block 51-51 --- 49 | { 50 | if (lhs.size() != rhs.size()) >> 51 | return false; 52 | 53 | for (size_t i = 0; i < lhs.size(); ++i) ================================================================================ src/Columns/tests/gtest_column_stable_permutation.cpp ================================================================================ --- uncovered block 63-64 --- 61 | [[maybe_unused]] static void printColumn(const IColumn & column) 62 | { >> 63 | size_t column_size = column.size(); >> 64 | Field value; 65 | 66 | for (size_t i = 0; i < column_size; ++i) ================================================================================ src/Common/Crypto/X509Certificate.cpp ================================================================================ --- uncovered block 56-56 --- 54 | certificate = PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr); 55 | if (!certificate) >> 56 | throw Exception(ErrorCodes::OPENSSL_ERROR, "PEM_read_bio_X509 failed for file {}: {}", path, getOpenSSLErrors()); 57 | } 58 | ================================================================================ src/Common/MemoryTracker.cpp ================================================================================ --- uncovered block 240-240 --- 238 | "{}{}: fault injected (at specific point)", 239 | description ? description : "", >> 240 | description ? " memory tracker" : "Memory tracker"); 241 | } 242 | ================================================================================ src/Common/OpenSSLHelpers.cpp ================================================================================ --- uncovered block 96-101 --- 94 | signature.resize(signature_length); 95 | >> 96 | return signature; 97 | } 98 | 99 | static bool genericSHA256Verify(EVP_PKEY * pkey, const std::string & data, const std::string & signature) 100 | { >> 101 | EVP_MD_CTX* ctx = EVP_MD_CTX_new(); 102 | 103 | if (!ctx) ================================================================================ src/Common/QueryProfiler.cpp ================================================================================ --- uncovered block 253-253 --- 251 | #if !defined(THREAD_SANITIZER) 252 | if (!hasPHDRCache()) >> 253 | throw Exception(ErrorCodes::NOT_IMPLEMENTED, "QueryProfiler cannot be used without PHDR cache in this build"); 254 | #endif 255 | --- uncovered block 269-273 --- 267 | 268 | if (sigaddset(&sa.sa_mask, pause_signal)) >> 269 | throw ErrnoException(ErrorCodes::CANNOT_MANIPULATE_SIGSET, "Failed to add signal to mask for query profiler"); 270 | #pragma clang diagnostic pop 271 | 272 | if (sigaction(pause_signal, &sa, nullptr)) >> 273 | throw ErrnoException(ErrorCodes::CANNOT_SET_SIGNAL_HANDLER, "Failed to setup signal handler for query profiler"); 274 | 275 | try ================================================================================ src/Common/StackTrace.cpp ================================================================================ --- uncovered block 596-596 --- 594 | { 595 | if (symbol_name.empty()) >> 596 | return "?"; 597 | 598 | if (file.has_value()) ================================================================================ src/Common/malloc.cpp ================================================================================ --- uncovered block 165-165 --- 163 | void * memalign(size_t alignment, size_t size) 164 | { >> 165 | void * res = nullptr; 166 | if (alignment == 0 || (alignment & (alignment - 1)) != 0) 167 | { --- uncovered block 223-230 --- 221 | #endif 222 | { >> 223 | size_t real_size = 0; >> 224 | if (__builtin_mul_overflow(nmemb, size, &real_size)) 225 | { 226 | errno = ENOMEM; 227 | return nullptr; 228 | } 229 | >> 230 | return realloc(ptr, real_size); 231 | } 232 | --- uncovered block 240-240 --- 238 | size_t malloc_usable_size(void * ptr) 239 | { >> 240 | return je_malloc_usable_size(ptr); 241 | } 242 | ================================================================================ src/Common/tests/gtest_DateLUTImpl.cpp ================================================================================ --- uncovered block 368-369 --- 366 | [[maybe_unused]] static std::ostream & operator<<(std::ostream & ostr, const DateLUTImpl::Values & v) 367 | { >> 368 | return ostr << "DateLUTImpl::Values{" >> 369 | << "\n\t date : " << v.date 370 | << "\n\t year : " << static_cast(v.year) 371 | << "\n\t month : " << static_cast(v.month) ================================================================================ src/Common/tests/gtest_os_thread_nice_value.cpp ================================================================================ --- uncovered block 20-21 --- 18 | static int getCurrentNiceValue(UInt32 thread_id = 0) 19 | { >> 20 | errno = 0; >> 21 | const int value = getpriority(PRIO_PROCESS, thread_id); 22 | if (value == -1 && errno != 0) 23 | { ================================================================================ src/Common/tests/gtest_resolve_pool.cpp ================================================================================ --- uncovered block 132-132 --- 130 | { 131 | if (container.empty()) >> 132 | return 0; 133 | 134 | size_t min_val = container.begin()->second; ================================================================================ src/Coordination/FourLetterCommand.cpp ================================================================================ --- uncovered block 661-662 --- 659 | static void printToString(void * output, const char * data) 660 | { >> 661 | std::string * output_data = reinterpret_cast(output); >> 662 | *output_data += std::string(data); 663 | } 664 | ================================================================================ src/Coordination/ZooKeeperDataReader.cpp ================================================================================ --- uncovered block 238-238 --- 236 | deserializeKeeperStorageFromSnapshot(storage, existing_snapshots.rbegin()->second, log); 237 | else >> 238 | throw Exception(ErrorCodes::CORRUPTED_DATA, "No snapshots found on path {}. At least one snapshot must exist.", path); 239 | } 240 | ================================================================================ src/Core/Field.cpp ================================================================================ --- uncovered block 204-204 --- 202 | } 203 | >> 204 | throw Exception(ErrorCodes::BAD_TYPE_OF_FIELD, "Bad type of Field"); 205 | } 206 | --- uncovered block 801-802 --- 799 | static void writeText(const Null & x, WriteBuffer & buf) 800 | { >> 801 | if (x.isNegativeInfinity()) >> 802 | writeText("-Inf", buf); 803 | if (x.isPositiveInfinity()) 804 | writeText("+Inf", buf); ================================================================================ src/Daemon/BaseDaemon.cpp ================================================================================ --- uncovered block 371-371 --- 369 | #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" 370 | if (!freopen(stderr_path.c_str(), "a+", stderr)) >> 371 | throw Poco::OpenFileException("Cannot attach stderr to " + stderr_path); 372 | 373 | /// Disable buffering for stderr --- uncovered block 384-384 --- 382 | #pragma clang diagnostic ignored "-Wdisabled-macro-expansion" 383 | if (!freopen(stdout_path.c_str(), "a+", stdout)) >> 384 | throw Poco::OpenFileException("Cannot attach stdout to " + stdout_path); 385 | #pragma clang diagnostic pop 386 | } ================================================================================ src/DataTypes/DataTypesBinaryEncoding.cpp ================================================================================ --- uncovered block 559-559 --- 557 | WriteBufferFromOwnString buf; 558 | encodeDataTypeImpl(type, buf); >> 559 | return buf.str(); 560 | } 561 | ================================================================================ src/DataTypes/tests/gtest_yt_schema.cpp ================================================================================ --- uncovered block 35-38 --- 33 | } 34 | >> 35 | [[maybe_unused]] static std::string createComplexTypeJson(const std::string & type_v3) { >> 36 | return fmt::format( >> 37 | R"({{"name": "id", "type": "any", "required": false, "type_v3": {}}})", >> 38 | type_v3); 39 | } 40 | ================================================================================ src/Databases/DataLake/PaimonRestCatalog.cpp ================================================================================ --- uncovered block 59-67 --- 57 | static String md5(const String & input) 58 | { >> 59 | Poco::MD5Engine md5; >> 60 | md5.update(input); >> 61 | return DB::base64Encode(String(reinterpret_cast(md5.digest().data()), md5.digestLength())); 62 | } 63 | 64 | static String bytesToHex(const String & bytes) 65 | { >> 66 | const char hex_digits[] = "0123456789abcdef"; >> 67 | DB::WriteBufferFromOwnString hex_str; 68 | for (const auto byte : bytes) 69 | { === Lost Baseline Coverage: 66 lines === ================================================================================ programs/server/Server.cpp ================================================================================ --- lost coverage block 1797-1800 --- 1795 | else 1796 | { >> 1797 | String calculated_binary_hash = getHashOfLoadedBinaryHex(); >> 1798 | if (calculated_binary_hash == stored_binary_hash) 1799 | { >> 1800 | LOG_INFO(log, "Integrity check of the executable successfully passed (checksum: {})", calculated_binary_hash); 1801 | } 1802 | else ================================================================================ src/AggregateFunctions/AggregateFunctionCount.cpp ================================================================================ --- lost coverage block 248-248 --- 246 | 247 | if (argument_types.size() > 1) >> 248 | throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires zero or one argument", name); 249 | 250 | return std::make_shared(argument_types); ================================================================================ src/AggregateFunctions/AggregateFunctionGroupArray.cpp ================================================================================ --- lost coverage block 760-760 --- 758 | return context->getServerSettings()[ServerSetting::aggregate_function_group_array_max_element_size]; 759 | >> 760 | return 0xFFFFFF; 761 | } 762 | ================================================================================ src/AggregateFunctions/AggregateFunctionGroupArraySorted.cpp ================================================================================ --- lost coverage block 392-392 --- 390 | if (parameters.empty()) 391 | { >> 392 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Parameter for aggregate function {} should have limit argument", name); 393 | } 394 | if (parameters.size() == 1) ================================================================================ src/AggregateFunctions/AggregateFunctionGroupBitmap.cpp ================================================================================ --- lost coverage block 250-251 --- 248 | WhichDataType which(*argument_type_ptr); 249 | if (which.idx != TypeIndex::AggregateFunction) >> 250 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}", >> 251 | argument_types[0]->getName(), name); 252 | 253 | /// groupBitmap needs to know about the data type that was used to create bitmaps. ================================================================================ src/AggregateFunctions/AggregateFunctionGroupConcat.cpp ================================================================================ --- lost coverage block 138-138 --- 136 | { 137 | if (cur_data.data_size != 0) >> 138 | cur_data.insertChar(delimiter.c_str(), delimiter.size(), arena); 139 | 140 | cur_data.insertChar(rhs_data.data, rhs_data.data_size, arena); --- lost coverage block 157-157 --- 155 | writeVarUInt(cur_data.num_rows, buf); 156 | for (const auto & offset : cur_data.offsets) >> 157 | writeVarUInt(offset, buf); 158 | } 159 | } --- lost coverage block 210-210 --- 208 | } 209 | >> 210 | if (cur_data.num_rows != 0 && cur_data.offsets.back() != cur_data.data_size) 211 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Invalid offsets in groupConcat state: last offset {} is not equal to data size {}", cur_data.offsets.back(), cur_data.data_size); 212 | } ================================================================================ src/AggregateFunctions/AggregateFunctionIntervalLengthSum.cpp ================================================================================ --- lost coverage block 105-133 --- 103 | void serialize(WriteBuffer & buf) const 104 | { >> 105 | writeBinary(sorted, buf); >> 106 | writeBinary(segments.size(), buf); 107 | >> 108 | for (const auto & time_gap : segments) 109 | { >> 110 | writeBinary(time_gap.first, buf); >> 111 | writeBinary(time_gap.second, buf); 112 | } 113 | } 114 | 115 | void deserialize(ReadBuffer & buf) 116 | { >> 117 | readBinary(sorted, buf); 118 | >> 119 | size_t size; >> 120 | readBinary(size, buf); 121 | >> 122 | if (unlikely(size > MAX_ARRAY_SIZE)) 123 | throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Too large array size (maximum: {})", MAX_ARRAY_SIZE); 124 | >> 125 | segments.clear(); >> 126 | segments.reserve(size); 127 | >> 128 | Segment segment; >> 129 | for (size_t i = 0; i < size; ++i) 130 | { >> 131 | readBinary(segment.first, buf); >> 132 | readBinary(segment.second, buf); >> 133 | segments.emplace_back(segment); 134 | } 135 | } --- lost coverage block 219-224 --- 217 | void serialize(ConstAggregateDataPtr __restrict place, WriteBuffer & buf, std::optional /* version */) const override 218 | { >> 219 | this->data(place).serialize(buf); 220 | } 221 | 222 | void deserialize(AggregateDataPtr __restrict place, ReadBuffer & buf, std::optional /* version */, Arena *) const override 223 | { >> 224 | this->data(place).deserialize(buf); 225 | } 226 | ================================================================================ src/AggregateFunctions/AggregateFunctionLargestTriangleThreeBuckets.cpp ================================================================================ --- lost coverage block 343-346 --- 341 | if (!(isNumber(argument_types[1]) || isDateOrDate32(argument_types[1]) || isDateTime(argument_types[1]) 342 | || isDateTime64(argument_types[1]))) >> 343 | throw Exception( >> 344 | ErrorCodes::NOT_IMPLEMENTED, >> 345 | "Aggregate function {} only supports Date, Date32, DateTime, DateTime64 and Number as the second argument", >> 346 | name); 347 | 348 | return std::make_shared(argument_types, parameters); ================================================================================ src/AggregateFunctions/AggregateFunctionQuantileBFloat16.cpp ================================================================================ --- lost coverage block 43-44 --- 41 | if (which.idx == TypeIndex::DateTime) return std::make_shared>(argument_types, params); 42 | >> 43 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}", >> 44 | argument_type->getName(), name); 45 | } 46 | ================================================================================ src/AggregateFunctions/AggregateFunctionQuantileBFloat16Weighted.cpp ================================================================================ --- lost coverage block 30-30 --- 28 | { 29 | if (argument_types.empty()) >> 30 | throw Exception(ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION, "Aggregate function {} requires at least one argument", name); 31 | 32 | const DataTypePtr & argument_type = argument_types[0]; ================================================================================ src/AggregateFunctions/AggregateFunctionQuantileDD.cpp ================================================================================ --- lost coverage block 32-32 --- 30 | { 31 | if (argument_types.empty()) >> 32 | throw Exception(ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION, "Aggregate function {} requires at least one argument", name); 33 | 34 | const DataTypePtr & argument_type = argument_types[0]; ================================================================================ src/AggregateFunctions/AggregateFunctionQuantileExactInclusive.cpp ================================================================================ --- lost coverage block 31-31 --- 29 | { 30 | if (argument_types.empty()) >> 31 | throw Exception(ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION, "Aggregate function {} requires at least one argument", name); 32 | 33 | const DataTypePtr & argument_type = argument_types[0]; ================================================================================ src/AggregateFunctions/AggregateFunctionQuantileExactLow.cpp ================================================================================ --- lost coverage block 46-50 --- 44 | if (which.idx == TypeIndex::Decimal64) return std::make_shared>(argument_types, params); 45 | if (which.idx == TypeIndex::Decimal128) return std::make_shared>(argument_types, params); >> 46 | if (which.idx == TypeIndex::Decimal256) return std::make_shared>(argument_types, params); >> 47 | if (which.idx == TypeIndex::DateTime64) return std::make_shared>(argument_types, params); 48 | >> 49 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}", >> 50 | argument_type->getName(), name); 51 | } 52 | ================================================================================ src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp ================================================================================ --- lost coverage block 813-814 --- 811 | { 812 | if (params.size() != 1) >> 813 | throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires exactly one parameter.", >> 814 | name); 815 | 816 | const auto arg_count = argument_types.size(); ================================================================================ src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp ================================================================================ --- lost coverage block 458-459 --- 456 | if (settings == nullptr || !(*settings)[Setting::allow_experimental_funnel_functions]) 457 | { >> 458 | throw Exception(ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION, "Aggregate function {} is experimental. " >> 459 | "Set `allow_experimental_funnel_functions` setting to enable it", name); 460 | } 461 | ================================================================================ src/AggregateFunctions/AggregateFunctionStatisticsSimple.h ================================================================================ --- lost coverage block 249-250 --- 247 | 248 | if (!res) >> 249 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}", >> 250 | argument_types[0]->getName(), name); 251 | return res; 252 | } ================================================================================ src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp ================================================================================ --- lost coverage block 313-314 --- 311 | 312 | if (argument_types.empty()) >> 313 | throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, >> 314 | "Incorrect number of arguments for aggregate function {}", name); 315 | 316 | bool use_exact_hash_function = !isAllArgumentsContiguousInMemory(argument_types); ================================================================================ src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp ================================================================================ --- lost coverage block 42-42 --- 40 | /// either sort whole container or do so partially merging ranges afterwards 41 | if (!prefix_sorted && !suffix_sorted) >> 42 | std::stable_sort(std::begin(events_list), std::end(events_list)); 43 | else 44 | { --- lost coverage block 637-639 --- 635 | return std::make_shared>>(arguments, params); 636 | } >> 637 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, >> 638 | "Illegal type {} of first argument of aggregate function {}, must " >> 639 | "be Unsigned Number, Date, DateTime", arguments.front().get()->getName(), name); 640 | } 641 | ================================================================================ src/AggregateFunctions/Combinators/AggregateFunctionArray.cpp ================================================================================ --- lost coverage block 39-40 --- 37 | nested_arguments.push_back(array->getNestedType()); 38 | else >> 39 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument" >> 40 | " for aggregate function with {} suffix. Must be array.", type->getName(), getName()); 41 | } 42 | ================================================================================ src/Common/ZooKeeper/ZooKeeper.cpp ================================================================================ --- lost coverage block 896-896 --- 894 | code == Coordination::Error::ZNONODE || 895 | code == Coordination::Error::ZBADVERSION)) >> 896 | throw KeeperException::fromPath(code, path); 897 | return code; 898 | } --- lost coverage block 1749-1749 --- 1747 | { 1748 | if (response.error != Coordination::Error::ZOK && response.error != Coordination::Error::ZNONODE) >> 1749 | promise->set_exception(std::make_exception_ptr(KeeperException::fromPath(response.error, path))); 1750 | else 1751 | promise->set_value(response); ================================================================================ src/Coordination/KeeperStorage.cpp ================================================================================ --- lost coverage block 1094-1094 --- 1092 | 1093 | if (delta_it == deltas.rend()) >> 1094 | rollback_deltas = std::move(deltas); 1095 | else 1096 | rollback_deltas.splice(rollback_deltas.end(), deltas, delta_it.base(), deltas.end()); --- lost coverage block 1145-1149 --- 1143 | else if (const auto * close_session = std::get_if(&delta.operation)) 1144 | { >> 1145 | auto & close_zxids = closed_sessions_to_zxids[close_session->session_id]; >> 1146 | [[maybe_unused]] auto erased = close_zxids.erase(delta.zxid); >> 1147 | chassert(erased == 1); >> 1148 | if (close_zxids.empty()) >> 1149 | closed_sessions_to_zxids.erase(close_session->session_id); 1150 | } 1151 | } ================================================================================ src/DataTypes/Serializations/SerializationQBit.cpp ================================================================================ --- lost coverage block 625-626 --- 623 | return TargetSpecific::x86_64_v4::untransposeBitPlaneBFloat16Impl(src, dst, stride_len, bit_mask); 624 | } >> 625 | #endif >> 626 | return TargetSpecific::Default::untransposeBitPlaneImpl(src, dst, stride_len, bit_mask); 627 | } 628 | WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set --- Coverage counts --- Lines : baseline 778,123/922,269 -> current 778,147/922,276 (delta +24 / +7) Functions : baseline 886,330/969,894 -> current 886,296/969,909 (delta -34 / +15) Branches : baseline 254,371/330,564 -> current 254,317/330,494 (delta -54 / -70)