================================================================================ 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: 83.62% (577/690) Uncovered changed code (with context): ================================================================================ src/Interpreters/InterpreterExplainQuery.cpp ================================================================================ --- uncovered block 860-867 --- 858 | if (auto * table_function = ast.getTableFunction()->as(); !table_function || table_function->name != "mysql") 859 | { >> 860 | throw Exception(ErrorCodes::INCORRECT_QUERY, "EXPLAIN TABLE OVERRIDE is not supported for the {}() table function", table_function->name); 861 | } >> 862 | auto storage = query_context->getQueryContext()->executeTableFunction(ast.getTableFunction()); >> 863 | auto metadata = storage->getInMemoryMetadataPtr(query_context, false); >> 864 | const StorageInMemoryMetadata & metadata_snapshot = *metadata; >> 865 | TableOverrideAnalyzer::Result override_info; >> 866 | TableOverrideAnalyzer override_analyzer(ast.getTableOverride()); >> 867 | override_analyzer.analyze(metadata_snapshot, override_info); 868 | override_info.appendTo(buf); 869 | break; ================================================================================ src/Interpreters/InterpreterSelectQuery.cpp ================================================================================ --- uncovered block 766-779 --- 764 | if (auto custom_key_ast = parseCustomKeyForTable(settings[Setting::parallel_replicas_custom_key], *context)) 765 | { >> 766 | LOG_TRACE(log, "Processing query on a replica using custom_key '{}'", settings[Setting::parallel_replicas_custom_key].value); 767 | >> 768 | auto custom_key_metadata = storage->getInMemoryMetadataPtr(context, false); >> 769 | parallel_replicas_custom_filter_ast = getCustomKeyFilterForParallelReplica( >> 770 | settings[Setting::parallel_replicas_count], >> 771 | settings[Setting::parallel_replica_offset], 772 | std::move(custom_key_ast), >> 773 | {settings[Setting::parallel_replicas_mode], >> 774 | settings[Setting::parallel_replicas_custom_key_range_lower], >> 775 | settings[Setting::parallel_replicas_custom_key_range_upper]}, >> 776 | custom_key_metadata->columns, >> 777 | context); 778 | } >> 779 | else if (settings[Setting::parallel_replica_offset] > 0) 780 | { 781 | throw Exception( ================================================================================ src/Interpreters/InterpreterWatchQuery.cpp ================================================================================ --- uncovered block 81-86 --- 79 | if (storage_name == "WindowView" && !getContext()->getSettingsRef()[Setting::allow_experimental_window_view]) 80 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 81 | "Experimental WINDOW VIEW feature is not enabled (the setting 'allow_experimental_window_view')"); 82 | 83 | /// List of columns to read to execute the query. >> 84 | auto metadata_snapshot = storage->getInMemoryMetadataPtr(getContext(), false); >> 85 | Names required_columns = metadata_snapshot->getColumns().getNamesOfPhysical(); >> 86 | getContext()->checkAccess(AccessType::SELECT, table_id, required_columns); 87 | 88 | /// Get context settings for this query ================================================================================ src/Planner/PlannerJoinTree.cpp ================================================================================ --- uncovered block 612-626 --- 610 | 611 | if (settings[Setting::parallel_replicas_count] <= 1 || settings[Setting::parallel_replicas_custom_key].value.empty()) >> 612 | return {}; 613 | >> 614 | auto custom_key_ast = parseCustomKeyForTable(settings[Setting::parallel_replicas_custom_key], *query_context); >> 615 | if (!custom_key_ast) >> 616 | throw DB::Exception( >> 617 | ErrorCodes::BAD_ARGUMENTS, >> 618 | "Parallel replicas processing with custom_key has been requested " 619 | "(setting 'max_parallel_replicas'), but the table does not have custom_key defined for it " >> 620 | " or it's invalid (setting 'parallel_replicas_custom_key')"); 621 | >> 622 | LOG_TRACE(getLogger("Planner"), "Processing query on a replica using custom_key '{}'", settings[Setting::parallel_replicas_custom_key].value); 623 | >> 624 | auto metadata_snapshot = storage->getInMemoryMetadataPtr(query_context, false); >> 625 | auto parallel_replicas_custom_filter_ast = getCustomKeyFilterForParallelReplica( >> 626 | settings[Setting::parallel_replicas_count], 627 | settings[Setting::parallel_replica_offset], 628 | std::move(custom_key_ast), --- uncovered block 1285-1286 --- 1283 | if (query_context->canUseParallelReplicasCustomKey() && query_context->getClientInfo().distributed_depth == 0) 1284 | { >> 1285 | if (auto cluster = query_context->getClusterForParallelReplicas(); >> 1286 | query_context->canUseParallelReplicasCustomKeyForCluster(*cluster)) 1287 | { 1288 | planner_context->getMutableQueryContext()->setSetting("prefer_localhost_replica", Field{0}); ================================================================================ src/Storages/MergeTree/MergeTreeData.cpp ================================================================================ --- uncovered block 10766-10766 --- 10764 | 10765 | if (!query_context->getSettingsRef()[Setting::enable_shared_storage_snapshot_in_query]) >> 10766 | return IStorage::getInMemoryMetadataPtr(query_context, bypass_metadata_cache); 10767 | 10768 | auto [cache, lock] = query_context->getQueryMetadataCache()->getStorageMetadataCache(); ================================================================================ src/Storages/MergeTree/MergeTreeIndexLegacyHypothesis.cpp ================================================================================ --- uncovered block 12-12 --- 10 | 11 | MergeTreeIndexLegacyHypothesis::MergeTreeIndexLegacyHypothesis(StorageMetadataPtr metadata_snapshot_, const IndexDescription & index_) >> 12 | : IMergeTreeIndex(std::move(metadata_snapshot_), index_) 13 | { 14 | } --- uncovered block 28-33 --- 26 | MergeTreeIndexConditionPtr MergeTreeIndexLegacyHypothesis::createIndexCondition(const ActionsDAG::Node *, ContextPtr) const 27 | { >> 28 | throw Exception(ErrorCodes::ILLEGAL_INDEX, "Index of type 'hypothesis' is no longer supported. Please drop the index"); 29 | } 30 | 31 | MergeTreeIndexPtr legacyHypothesisIndexCreator(StorageMetadataPtr metadata_snapshot, const IndexDescription & index) 32 | { >> 33 | return std::make_shared(std::move(metadata_snapshot), index); 34 | } 35 | ================================================================================ src/Storages/MergeTree/MergeTreeIndexText.cpp ================================================================================ --- uncovered block 1789-1789 --- 1787 | 1788 | if (!options.empty()) >> 1789 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected text index arguments: {}", fmt::join(std::views::keys(options), ", ")); 1790 | 1791 | return std::make_shared(std::move(metadata_snapshot), index, index_params, std::move(tokenizer), std::move(posting_list_codec)); ================================================================================ src/Storages/MergeTree/MergeTreeIndices.cpp ================================================================================ --- uncovered block 110-110 --- 108 | return left + ", " + right.first; 109 | }) >> 110 | ); 111 | } 112 | ================================================================================ src/Storages/MergeTree/PatchParts/RangesInPatchParts.cpp ================================================================================ --- uncovered block 271-271 --- 269 | /// Check that index exists in data part. It may be absent for parts created in earlier versions. 270 | if (!index_ptr->getDeserializedFormat(patch_part->checksums, index_ptr->getFileName())) >> 271 | return {}; 272 | 273 | size_t total_marks_without_final = patch_part->index_granularity->getMarksCountWithoutFinal(); ================================================================================ src/Storages/MergeTree/StorageFromMergeTreeDataPart.h ================================================================================ --- uncovered block 40-44 --- 38 | : IStorage(storage_.getStorageID()), storage(storage_), analysis_result_ptr(analysis_result_ptr_) 39 | { >> 40 | auto storage_metadata_snapshot = storage.getInMemoryMetadataPtr(storage.getContext(), false); >> 41 | setInMemoryMetadata(*storage_metadata_snapshot); 42 | } 43 | >> 44 | String getName() const override { return "FromMergeTreeDataPart"; } 45 | 46 | void read( ================================================================================ src/Storages/ObjectStorage/StorageObjectStorageCluster.cpp ================================================================================ --- uncovered block 220-220 --- 218 | auto state = configuration->getTableStateSnapshot(query_context); 219 | if (!state) >> 220 | return; 221 | 222 | auto current_metadata = getInMemoryMetadataPtr(query_context, false); ================================================================================ src/Storages/ObjectStorageQueue/ObjectStorageQueueSettings.cpp ================================================================================ --- uncovered block 100-100 --- 98 | auto settings_changes_ast = metadata_snapshot->settings_changes; 99 | if (!settings_changes_ast) >> 100 | return; 101 | 102 | /// We cannot use setting.isValueChanged(), because we do not store initial settings in storage. ================================================================================ src/Storages/StorageInMemoryMetadata.h ================================================================================ --- uncovered block 354-354 --- 352 | public: 353 | StorageMetadataHandle() = default; >> 354 | StorageMetadataHandle(std::nullptr_t) {} /// NOLINT(google-explicit-constructor) 355 | StorageMetadataHandle(std::shared_ptr metadata_); /// NOLINT(google-explicit-constructor) 356 | StorageMetadataHandle(std::shared_ptr metadata_); /// NOLINT(google-explicit-constructor) ================================================================================ src/Storages/StorageMaterializedView.cpp ================================================================================ --- uncovered block 408-408 --- 406 | 407 | if (query_info.order_optimizer) >> 408 | query_info.input_order_info = query_info.order_optimizer->getInputOrder(target_metadata_snapshot, context); 409 | 410 | if (!view_metadata->select.select_table_id.empty()) --- uncovered block 463-476 --- 461 | SinkToStoragePtr StorageMaterializedView::write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr local_context, bool async_insert) 462 | { >> 463 | auto view_metadata = getInMemoryMetadataPtr(local_context, false); >> 464 | auto context = view_metadata->getSQLSecurityOverriddenContext(local_context); >> 465 | auto storage = getTargetTable(); >> 466 | auto lock = storage->lockForShare(context->getCurrentQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]); >> 467 | auto metadata_snapshot = storage->getInMemoryMetadataPtr(context, false); 468 | 469 | auto storage_id = storage->getStorageID(); 470 | 471 | /// TODO: remove sql_security_type check after we turn `ignore_empty_sql_security_in_create_view_query=false` 472 | /// We don't need to check access if the inner table was created automatically. >> 473 | if (!has_inner_table && !storage_id.empty() && view_metadata->sql_security_type) 474 | { >> 475 | auto query_sample_block = InterpreterInsertQuery::getSampleBlock(query->as(), storage, metadata_snapshot, context); >> 476 | context->checkAccess(AccessType::INSERT, storage_id, query_sample_block.getNames()); 477 | } 478 | --- uncovered block 1020-1020 --- 1018 | auto table = tryGetTargetTable(); 1019 | if (!table) >> 1020 | return std::nullopt; 1021 | 1022 | auto view_metadata = getInMemoryMetadataPtr(getContext(), false); ================================================================================ src/Storages/StorageMergeTree.cpp ================================================================================ --- uncovered block 341-351 --- 339 | if (local_context->canUseParallelReplicasCustomKeyForCluster(*cluster)) 340 | { >> 341 | auto modified_query_info = query_info; >> 342 | modified_query_info.cluster = std::move(cluster); >> 343 | auto metadata_snapshot = getInMemoryMetadataPtr(local_context, false); >> 344 | ClusterProxy::executeQueryWithParallelReplicasCustomKey( >> 345 | query_plan, >> 346 | getStorageID(), >> 347 | std::move(modified_query_info), >> 348 | metadata_snapshot->getColumns(), >> 349 | storage_snapshot, >> 350 | processed_stage, >> 351 | query_info.query, 352 | local_context); 353 | return; --- uncovered block 2740-2741 --- 2738 | auto dest_uk_metadata_snapshot = dest_table_storage->getInMemoryMetadataPtr(local_context, false); 2739 | if (dest_uk_metadata_snapshot->hasUniqueKey()) >> 2740 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 2741 | "MOVE PARTITION TO a destination table with UNIQUE KEY is not supported"); 2742 | bool are_policies_partition_op_compatible = getStoragePolicy()->isCompatibleForPartitionOps(dest_table_storage->getStoragePolicy()); 2743 | ================================================================================ src/Storages/StorageReplicatedMergeTree.cpp ================================================================================ --- uncovered block 6183-6193 --- 6181 | if (local_context->canUseParallelReplicasCustomKeyForCluster(*cluster)) 6182 | { >> 6183 | auto modified_query_info = query_info; >> 6184 | modified_query_info.cluster = std::move(cluster); >> 6185 | auto metadata_snapshot = getInMemoryMetadataPtr(local_context, false); >> 6186 | ClusterProxy::executeQueryWithParallelReplicasCustomKey( >> 6187 | query_plan, >> 6188 | getStorageID(), >> 6189 | std::move(modified_query_info), >> 6190 | metadata_snapshot->getColumns(), >> 6191 | storage_snapshot, >> 6192 | processed_stage, >> 6193 | query_info.query, 6194 | local_context); 6195 | return; --- uncovered block 6405-6412 --- 6403 | 6404 | if (!is_leader) >> 6405 | throw Exception(ErrorCodes::NOT_A_LEADER, "OPTIMIZE cannot be done on this replica because it is not a leader"); 6406 | 6407 | const auto mode = (*getSettings())[MergeTreeSetting::deduplicate_merge_projection_mode]; 6408 | auto projections_metadata_snapshot = getInMemoryMetadataPtr(query_context, false); 6409 | if (deduplicate && projections_metadata_snapshot->hasProjections() 6410 | && (mode == DeduplicateMergeProjectionMode::THROW || mode == DeduplicateMergeProjectionMode::IGNORE)) >> 6411 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 6412 | "OPTIMIZE DEDUPLICATE query is not supported for table {} as it has projections. " 6413 | "Please drop all projections manually before running the query, " 6414 | "or set setting 'deduplicate_merge_projection_mode' to 'drop' or 'rebuild'", ================================================================================ src/Storages/StorageTableFunction.h ================================================================================ --- uncovered block 135-135 --- 133 | if (!blocksHaveEqualStructure(actual_structure, cached_structure) && add_conversion) 134 | { >> 135 | throw Exception(ErrorCodes::INCOMPATIBLE_COLUMNS, "Source storage and table function have different structure"); 136 | } 137 | return storage->write(query, metadata_snapshot, context, async_insert); ================================================================================ src/Storages/StorageView.cpp ================================================================================ --- uncovered block 210-210 --- 208 | /// poisoning the schema cache with wrong column names. 209 | if (context->hasInsertionTable()) >> 210 | return nullptr; 211 | 212 | auto metadata_snapshot = getInMemoryMetadataPtr(context, false); ================================================================================ src/Storages/System/StorageSystemPartsBase.cpp ================================================================================ --- uncovered block 93-93 --- 91 | auto metadata_snapshot = data->getInMemoryMetadataPtr(CurrentThread::tryGetQueryContext(), false); 92 | if (metadata_snapshot->projections.empty()) >> 93 | return {}; 94 | 95 | using State = MergeTreeData::DataPartState; ================================================================================ src/Storages/TimeSeries/PrometheusRemoteWriteProtocol.cpp ================================================================================ --- uncovered block 665-671 --- 663 | auto time_series_storage_id = time_series_storage->getStorageID(); 664 | >> 665 | LOG_TRACE(log, "{}: Writing {} metrics metadata", >> 666 | time_series_storage_id.getNameForLogs(), metrics_metadata.size()); 667 | >> 668 | auto metrics_table_metadata_ptr = time_series_storage->getTargetTable(ViewTarget::Metrics, getContext())->getInMemoryMetadataPtr(getContext(), false); >> 669 | const auto & metrics_table_metadata = *metrics_table_metadata_ptr; >> 670 | auto blocks = toBlocks(metrics_metadata, metrics_table_metadata); >> 671 | insertToTargetTables(std::move(blocks), *time_series_storage, getContext(), log.get()); 672 | 673 | LOG_TRACE(log, "{}: {} metrics metadata written", ================================================================================ src/Storages/TimeSeries/normalizeTimeSeriesDefinition.cpp ================================================================================ --- uncovered block 247-247 --- 245 | auto external_table = DatabaseCatalog::instance().tryGetTable(context->tryResolveStorageID(external_table_id), context); 246 | if (!external_table) >> 247 | throw Exception(ErrorCodes::UNKNOWN_TABLE, "TimeSeries: Target table {} doesn't exist", external_table_id.getNameForLogs()); 248 | auto external_metadata = external_table->getInMemoryMetadataPtr(context, false); 249 | return {external_table_id, external_metadata->columns}; ================================================================================ src/Storages/WindowView/StorageWindowView.cpp ================================================================================ --- uncovered block 479-485 --- 477 | AlterLockHolder &) 478 | { >> 479 | throwIfWindowViewIsDisabled(local_context); >> 480 | auto table_id = getStorageID(); >> 481 | auto current_metadata = getInMemoryMetadataPtr(local_context, false); >> 482 | StorageInMemoryMetadata new_metadata = *current_metadata; >> 483 | params.apply(new_metadata, local_context); 484 | >> 485 | const auto & new_select = new_metadata.select; 486 | const auto & new_select_query = new_metadata.select.inner_query; 487 | --- uncovered block 726-735 --- 724 | auto block_io = interpreter.execute(); 725 | >> 726 | auto pipe = Pipe(std::make_shared(blocks, std::make_shared(std::move(header)))); 727 | >> 728 | auto target_metadata_snapshot = getTargetTable()->getInMemoryMetadataPtr(context, false); >> 729 | auto adding_missing_defaults_dag = addMissingDefaults( >> 730 | pipe.getHeader(), >> 731 | block_io.pipeline.getHeader().getNamesAndTypesList(), >> 732 | target_metadata_snapshot->getColumns(), >> 733 | context, >> 734 | context->getSettingsRef()[Setting::insert_null_as_default]); >> 735 | auto adding_missing_defaults_actions = std::make_shared(std::move(adding_missing_defaults_dag)); 736 | pipe.addSimpleTransform([&](const SharedHeader & stream_header) 737 | { ================================================================================ src/TableFunctions/TableFunctionLoop.cpp ================================================================================ --- uncovered block 114-114 --- 112 | auto storage = database->tryGetTable(loop_table_name, context); 113 | if (!storage) >> 114 | throw Exception(ErrorCodes::UNKNOWN_TABLE, "Table '{}' not found in database '{}'", loop_table_name, database_name); 115 | 116 | auto metadata_snapshot = storage->getInMemoryMetadataPtr(context, false); ================================================================================ src/TableFunctions/TableFunctionMergeTreeTextIndex.cpp ================================================================================ --- uncovered block 108-109 --- 106 | throw Exception( 107 | ErrorCodes::BAD_ARGUMENTS, >> 108 | "Got index '{}' of type '{}', expected 'text'", >> 109 | source_index_name, index_desc.type); 110 | 111 | auto text_index = MergeTreeIndexFactory::instance().get(metadata_snapshot, index_desc); === Lost Baseline Coverage: 37 lines === ================================================================================ src/Planner/PlannerJoinTree.cpp ================================================================================ --- lost coverage block 497-497 --- 495 | { 496 | throw Exception(ErrorCodes::LOGICAL_ERROR, "Expected table, table function, query or union. Actual {}", >> 497 | table_expression->formatASTForErrorMessage()); 498 | } 499 | ================================================================================ src/Storages/MergeTree/IMergeTreeDataPart.cpp ================================================================================ --- lost coverage block 2040-2040 --- 2038 | } 2039 | else >> 2040 | throw Exception(ErrorCodes::BAD_TTL_FILE, "Unknown ttl format version: {}", toString(format_version)); 2041 | } 2042 | } ================================================================================ src/Storages/MergeTree/MergeTreeData.cpp ================================================================================ --- lost coverage block 9100-9109 --- 9098 | else if (block.has(name)) 9099 | res.insert(block.getByName(name)); >> 9100 | else if (startsWith(name, "count")) // special case to match count(...) variants 9101 | { 9102 | const auto & column = block.getByName("count()"); 9103 | res.insert({column.column, column.type, name}); 9104 | } 9105 | else >> 9106 | throw Exception( 9107 | ErrorCodes::LOGICAL_ERROR, >> 9108 | "Cannot find column {} in minmax_count projection but query analysis still selects this projection. It's a bug", >> 9109 | name); 9110 | } 9111 | --- lost coverage block 10766-10766 --- 10764 | 10765 | if (!query_context->getSettingsRef()[Setting::enable_shared_storage_snapshot_in_query]) >> 10766 | return IStorage::getInMemoryMetadataPtr(query_context, bypass_metadata_cache); 10767 | 10768 | auto [cache, lock] = query_context->getQueryMetadataCache()->getStorageMetadataCache(); ================================================================================ src/Storages/MergeTree/MergeTreeIndexBloomFilterText.cpp ================================================================================ --- lost coverage block 754-754 --- 752 | } 753 | >> 754 | return false; 755 | } 756 | ================================================================================ src/Storages/ObjectStorageQueue/StorageObjectStorageQueue.cpp ================================================================================ --- lost coverage block 527-527 --- 525 | files_metadata.reset(); 526 | } >> 527 | LOG_TRACE(log, "Shut down storage"); 528 | } 529 | ================================================================================ src/Storages/StorageBuffer.cpp ================================================================================ --- lost coverage block 1230-1230 --- 1228 | /// Schedule flush in background immediately, otherwise in case of frequent INSERTs we will never schedule the background flush 1229 | if (reschedule_sec == 0) >> 1230 | flush_handle->schedule(); 1231 | else 1232 | flush_handle->scheduleAfter(reschedule_sec * 1000); ================================================================================ src/Storages/StorageFile.cpp ================================================================================ --- lost coverage block 837-839 --- 835 | /// For union mode next() will be called again even if we found cached columns, 836 | /// so we need to remember last_read_buffer to continue iterating through files in archive. >> 837 | if (getContext()->getSettingsRef()[Setting::schema_inference_mode] == SchemaInferenceMode::UNION) >> 838 | last_read_buffer = archive_reader->readFile(std::move(file_enumerator)); >> 839 | return {nullptr, cached_schema, format}; 840 | } 841 | --- lost coverage block 929-929 --- 927 | auto cache_key = getKeyForSchemaCache(full_path, *format, format_settings, context); 928 | if (auto columns = schema_cache.tryGetColumns(cache_key, get_last_mod_time)) >> 929 | return columns; 930 | } 931 | else --- lost coverage block 1301-1301 --- 1299 | Int64 lock_timeout = settings[Setting::lock_acquire_timeout].totalSeconds(); 1300 | if (settings[Setting::max_execution_time].totalSeconds() != 0 && settings[Setting::max_execution_time].totalSeconds() < lock_timeout) >> 1301 | lock_timeout = settings[Setting::max_execution_time].totalSeconds(); 1302 | return std::chrono::seconds{lock_timeout}; 1303 | } ================================================================================ src/Storages/StorageMaterializedView.cpp ================================================================================ --- lost coverage block 988-988 --- 986 | if (auto table = tryGetTargetTable()) 987 | return table->isRemote(); >> 988 | return false; 989 | } 990 | ================================================================================ src/Storages/StorageReplicatedMergeTree.cpp ================================================================================ --- lost coverage block 2762-2762 --- 2760 | /* try_fetch_shared= */ true)) 2761 | { >> 2762 | return false; 2763 | } 2764 | } --- lost coverage block 3629-3631 --- 3627 | else if (info.parsed_entry->type == LogEntry::GET_PART) 3628 | { >> 3629 | String maybe_covering_drop_range = drop_range_set.getContainingPart(info.parsed_entry->new_part_name); >> 3630 | if (maybe_covering_drop_range.empty()) >> 3631 | get_part_set.add(info.parsed_entry->new_part_name); 3632 | } 3633 | else --- lost coverage block 4201-4202 --- 4199 | { 4200 | /// Part cannot be added temporarily >> 4201 | LOG_INFO(log, getExceptionMessageAndPattern(e, /* with_stacktrace */ false)); >> 4202 | cleanup_thread.wakeup(); 4203 | } 4204 | else --- lost coverage block 5446-5449 --- 5444 | if (auto part = getPartIfExists(part_info, {MergeTreeDataPartState::Outdated, MergeTreeDataPartState::Deleting})) 5445 | { >> 5446 | LOG_DEBUG(log, "Part {} should be deleted after previous attempt before fetch", part->name); 5447 | /// Force immediate parts cleanup to delete the part that was left from the previous fetch attempt. >> 5448 | cleanup_thread.wakeup(); >> 5449 | return false; 5450 | } 5451 | } --- lost coverage block 8350-8359 --- 8348 | break; 8349 | } >> 8350 | if (rc == Coordination::Error::ZBADVERSION) 8351 | { 8352 | /// Cannot retry automatically, because some zookeeper ops were lost on the first attempt. Will retry on DDLWorker-level. >> 8353 | if (query_context->getZooKeeperMetadataTransaction()) 8354 | throw Exception( 8355 | ErrorCodes::CANNOT_ASSIGN_ALTER, 8356 | "Cannot execute alter, because mutations version was suddenly changed due " 8357 | "to concurrent alter"); >> 8358 | LOG_TRACE(log, "Version conflict when trying to create a mutation node, retrying..."); >> 8359 | continue; 8360 | } 8361 | throw Coordination::Exception::fromMessage(rc, "Unable to create a mutation znode"); --- lost coverage block 10245-10245 --- 10243 | else 10244 | { >> 10245 | return toString(UUIDHelpers::Nil); 10246 | } 10247 | --- lost coverage block 11270-11272 --- 11268 | else 11269 | { >> 11270 | throw Exception(ErrorCodes::DUPLICATE_DATA_PART, >> 11271 | "Part {} already exists on replica {} on path {}", >> 11272 | lost_part_name, replica, current_part_path); 11273 | } 11274 | } --- lost coverage block 11319-11320 --- 11317 | catch (const Exception & ex) 11318 | { >> 11319 | LOG_WARNING(log, "Cannot commit empty part {} with error {}", lost_part_name, ex.displayText()); >> 11320 | return false; 11321 | } 11322 | ================================================================================ src/Storages/StorageURL.cpp ================================================================================ --- lost coverage block 620-623 --- 618 | /// If all options are unreachable except empty ones that we skipped, 619 | /// return last empty result. It will be skipped later. >> 620 | if (last_skipped_empty_res.second) 621 | return last_skipped_empty_res; 622 | >> 623 | throw Exception(ErrorCodes::NETWORK_ERROR, "All uri ({}) options are unreachable: {}", options, first_exception_message); 624 | } 625 | WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set --- Coverage counts --- Lines : baseline 780,321/924,304 -> current 780,511/924,436 (delta +190 / +132) Functions : baseline 886,263/959,495 -> current 886,288/959,506 (delta +25 / +11) Branches : baseline 255,085/331,424 -> current 255,098/331,424 (delta +13 / +0)