================================================================================ 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: 82.88% (857/1034) Uncovered changed code (with context): ================================================================================ src/Interpreters/InterpreterExplainQuery.cpp ================================================================================ --- uncovered block 875-882 --- 873 | if (auto * table_function = ast.getTableFunction()->as(); !table_function || table_function->name != "mysql") 874 | { >> 875 | throw Exception(ErrorCodes::INCORRECT_QUERY, "EXPLAIN TABLE OVERRIDE is not supported for the {}() table function", table_function->name); 876 | } >> 877 | auto storage = query_context->getQueryContext()->executeTableFunction(ast.getTableFunction()); >> 878 | auto metadata = storage->getInMemoryMetadataPtr(query_context, false); >> 879 | const StorageInMemoryMetadata & metadata_snapshot = *metadata; >> 880 | TableOverrideAnalyzer::Result override_info; >> 881 | TableOverrideAnalyzer override_analyzer(ast.getTableOverride()); >> 882 | override_analyzer.analyze(metadata_snapshot, override_info); 883 | override_info.appendTo(buf); 884 | break; ================================================================================ src/Interpreters/InterpreterSelectQuery.cpp ================================================================================ --- uncovered block 786-799 --- 784 | if (auto custom_key_ast = parseCustomKeyForTable(settings[Setting::parallel_replicas_custom_key], *context)) 785 | { >> 786 | LOG_TRACE(log, "Processing query on a replica using custom_key '{}'", settings[Setting::parallel_replicas_custom_key].value); 787 | >> 788 | auto custom_key_metadata = storage->getInMemoryMetadataPtr(context, false); >> 789 | parallel_replicas_custom_filter_ast = getCustomKeyFilterForParallelReplica( >> 790 | settings[Setting::parallel_replicas_count], >> 791 | settings[Setting::parallel_replica_offset], 792 | std::move(custom_key_ast), >> 793 | {settings[Setting::parallel_replicas_mode], >> 794 | settings[Setting::parallel_replicas_custom_key_range_lower], >> 795 | settings[Setting::parallel_replicas_custom_key_range_upper]}, >> 796 | custom_key_metadata->columns, >> 797 | context); 798 | } >> 799 | else if (settings[Setting::parallel_replica_offset] > 0) 800 | { 801 | 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/Processors/QueryPlan/ReadFromLoopStep.cpp ================================================================================ --- uncovered block 143-147 --- 141 | else 142 | { >> 143 | const auto metadata_snapshot = inner_storage->getInMemoryMetadataPtr(context, false); >> 144 | auto inner_storage_snapshot = inner_storage->getStorageSnapshot(metadata_snapshot, context); >> 145 | inner_storage->read( >> 146 | plan, >> 147 | column_names, 148 | inner_storage_snapshot, 149 | query_info, ================================================================================ src/Storages/MergeTree/IMergeTreeDataPart.cpp ================================================================================ --- uncovered block 1966-1972 --- 1964 | return rows_count; 1965 | >> 1966 | NamesAndTypesList cols; >> 1967 | cols.emplace_back(RowExistsColumn::name, RowExistsColumn::type); 1968 | >> 1969 | const auto metadata_ptr = storage.getInMemoryMetadataPtr(storage.getContext(), false); >> 1970 | StorageSnapshotPtr storage_snapshot_ptr = std::make_shared(storage, metadata_ptr); 1971 | >> 1972 | auto alter_conversions = std::make_shared(); 1973 | auto part_info = std::make_shared(shared_from_this(), alter_conversions); 1974 | ================================================================================ src/Storages/MergeTree/MergeTreeData.cpp ================================================================================ --- uncovered block 5859-5864 --- 5857 | void MergeTreeData::outdateUnexpectedPartAndCloneToDetached(const DataPartPtr & part_to_detach) 5858 | { >> 5859 | LOG_INFO(log, "Cloning part {} to unexpected_{} and making it obsolete.", part_to_detach->getDataPartStorage().getPartDirectory(), part_to_detach->name); >> 5860 | const auto metadata_snapshot = getInMemoryMetadataPtr(getContext(), false); >> 5861 | part_to_detach->makeCloneInDetached("unexpected", metadata_snapshot, /*disk_transaction*/ {}); 5862 | >> 5863 | auto lock = lockParts(); >> 5864 | part_to_detach->is_unexpected_local_part = true; 5865 | if (part_to_detach->getState() == DataPartState::Active) 5866 | removePartsFromWorkingSet(NO_TRANSACTION_RAW, {part_to_detach}, true, lock); --- uncovered block 10871-10871 --- 10869 | 10870 | if (!query_context->getSettingsRef()[Setting::enable_shared_storage_snapshot_in_query]) >> 10871 | return IStorage::getInMemoryMetadataPtr(query_context, bypass_metadata_cache); 10872 | 10873 | 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, const MergeTreeSettings & /*settings*/) 32 | { >> 33 | return std::make_shared(std::move(metadata_snapshot), index); 34 | } 35 | ================================================================================ src/Storages/MergeTree/MergeTreeIndexText.cpp ================================================================================ --- uncovered block 1771-1771 --- 1769 | 1770 | if (!options.empty()) >> 1771 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected text index arguments: {}", fmt::join(std::views::keys(options), ", ")); 1772 | 1773 | 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 133-133 --- 131 | return left + ", " + right.first; 132 | }) >> 133 | ); 134 | } 135 | ================================================================================ src/Storages/MergeTree/PatchParts/RangesInPatchParts.cpp ================================================================================ --- uncovered block 273-273 --- 271 | /// Check that index exists in data part. It may be absent for parts created in earlier versions. 272 | if (!index_ptr->getDeserializedFormat(patch_part->checksums, index_ptr->getFileName(), &patch_part->getDataPartStorage())) >> 273 | return {}; 274 | 275 | 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/NATS/StorageNATS.cpp ================================================================================ --- uncovered block 708-714 --- 706 | /* no_squash */ true, 707 | /* no_destination */ true, >> 708 | /* async_isnert */ false); >> 709 | auto block_io = interpreter.execute(); 710 | >> 711 | const auto metadata_snapshot = getInMemoryMetadataPtr(getContext(), false); >> 712 | auto storage_snapshot = getStorageSnapshot(metadata_snapshot, getContext()); >> 713 | auto column_names = block_io.pipeline.getHeader().getNames(); >> 714 | auto sample_block = storage_snapshot->getSampleBlockForColumns(column_names); 715 | 716 | auto block_size = getMaxBlockSize(); ================================================================================ src/Storages/ObjectStorage/StorageObjectStorageCluster.cpp ================================================================================ --- uncovered block 245-245 --- 243 | auto state = configuration->getTableStateSnapshot(query_context); 244 | if (!state) >> 245 | return; 246 | 247 | auto current_metadata = getInMemoryMetadataPtr(query_context, false); ================================================================================ src/Storages/ObjectStorageQueue/ObjectStorageQueueSettings.cpp ================================================================================ --- uncovered block 101-101 --- 99 | auto settings_changes_ast = metadata_snapshot->settings_changes; 100 | if (!settings_changes_ast) >> 101 | return; 102 | 103 | /// 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 419-419 --- 417 | 418 | if (query_info.order_optimizer) >> 419 | query_info.input_order_info = query_info.order_optimizer->getInputOrder(target_metadata_snapshot, context); 420 | 421 | if (!view_metadata->select.select_table_id.empty()) --- uncovered block 474-487 --- 472 | SinkToStoragePtr StorageMaterializedView::write(const ASTPtr & query, const StorageMetadataPtr & /*metadata_snapshot*/, ContextPtr local_context, bool async_insert) 473 | { >> 474 | auto view_metadata = getInMemoryMetadataPtr(local_context, false); >> 475 | auto context = view_metadata->getSQLSecurityOverriddenContext(local_context); >> 476 | auto storage = getTargetTable(); >> 477 | auto lock = storage->lockForShare(context->getCurrentQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]); >> 478 | auto metadata_snapshot = storage->getInMemoryMetadataPtr(context, false); 479 | 480 | auto storage_id = storage->getStorageID(); 481 | 482 | /// TODO: remove sql_security_type check after we turn `ignore_empty_sql_security_in_create_view_query=false` 483 | /// We don't need to check access if the inner table was created automatically. >> 484 | if (!has_inner_table && !storage_id.empty() && view_metadata->sql_security_type) 485 | { >> 486 | auto query_sample_block = InterpreterInsertQuery::getSampleBlock(query->as(), storage, metadata_snapshot, context); >> 487 | context->checkAccess(AccessType::INSERT, storage_id, query_sample_block.getNames()); 488 | } 489 | --- uncovered block 1031-1031 --- 1029 | auto table = tryGetTargetTable(); 1030 | if (!table) >> 1031 | return std::nullopt; 1032 | 1033 | auto view_metadata = getInMemoryMetadataPtr(getContext(), false); ================================================================================ src/Storages/StorageMergeTree.cpp ================================================================================ --- uncovered block 348-358 --- 346 | if (local_context->canUseParallelReplicasCustomKeyForCluster(*cluster)) 347 | { >> 348 | auto modified_query_info = query_info; >> 349 | modified_query_info.cluster = std::move(cluster); >> 350 | auto metadata_snapshot = getInMemoryMetadataPtr(local_context, false); >> 351 | ClusterProxy::executeQueryWithParallelReplicasCustomKey( >> 352 | query_plan, >> 353 | getStorageID(), >> 354 | std::move(modified_query_info), >> 355 | metadata_snapshot->getColumns(), >> 356 | storage_snapshot, >> 357 | processed_stage, >> 358 | query_info.query, 359 | local_context); 360 | return; --- uncovered block 2748-2749 --- 2746 | auto dest_uk_metadata_snapshot = dest_table_storage->getInMemoryMetadataPtr(local_context, false); 2747 | if (dest_uk_metadata_snapshot->hasUniqueKey()) >> 2748 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 2749 | "MOVE PARTITION TO a destination table with UNIQUE KEY is not supported"); 2750 | bool are_policies_partition_op_compatible = getStoragePolicy()->isCompatibleForPartitionOps(dest_table_storage->getStoragePolicy()); 2751 | ================================================================================ src/Storages/StorageMergeTreeAnalyzeIndexes.cpp ================================================================================ --- uncovered block 130-130 --- 128 | const auto * merge_tree_data = dynamic_cast(storage.get()); 129 | if (!merge_tree_data) >> 130 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Storage MergeTreeAnalyzeIndexes expected MergeTree table, got: {}", storage->getName()); 131 | 132 | std::optional filter_dag; ================================================================================ src/Storages/StorageReplicatedMergeTree.cpp ================================================================================ --- uncovered block 6213-6223 --- 6211 | if (local_context->canUseParallelReplicasCustomKeyForCluster(*cluster)) 6212 | { >> 6213 | auto modified_query_info = query_info; >> 6214 | modified_query_info.cluster = std::move(cluster); >> 6215 | auto metadata_snapshot = getInMemoryMetadataPtr(local_context, false); >> 6216 | ClusterProxy::executeQueryWithParallelReplicasCustomKey( >> 6217 | query_plan, >> 6218 | getStorageID(), >> 6219 | std::move(modified_query_info), >> 6220 | metadata_snapshot->getColumns(), >> 6221 | storage_snapshot, >> 6222 | processed_stage, >> 6223 | query_info.query, 6224 | local_context); 6225 | return; --- uncovered block 6438-6445 --- 6436 | 6437 | if (!is_leader) >> 6438 | throw Exception(ErrorCodes::NOT_A_LEADER, "OPTIMIZE cannot be done on this replica because it is not a leader"); 6439 | 6440 | const auto mode = (*getSettings())[MergeTreeSetting::deduplicate_merge_projection_mode]; 6441 | auto projections_metadata_snapshot = getInMemoryMetadataPtr(query_context, false); 6442 | if (deduplicate && projections_metadata_snapshot->hasProjections() 6443 | && (mode == DeduplicateMergeProjectionMode::THROW || mode == DeduplicateMergeProjectionMode::IGNORE)) >> 6444 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 6445 | "OPTIMIZE DEDUPLICATE query is not supported for table {} as it has projections. " 6446 | "Please drop all projections manually before running the query, " 6447 | "or set setting 'deduplicate_merge_projection_mode' to 'drop' or 'rebuild'", --- uncovered block 9676-9680 --- 9674 | { 9675 | /// Optimistic check that for compatible destination table structure. >> 9676 | const auto storage_metadata = getInMemoryMetadataPtr(getContext(), false); >> 9677 | checkTableStructure(to, storage_metadata, /* metadata_version = */ nullptr, /* strict_check = */ true, /* zookeeper_retries_info = */ {}); 9678 | } 9679 | >> 9680 | PinnedPartUUIDs src_pins; 9681 | PinnedPartUUIDs dst_pins; 9682 | ================================================================================ src/Storages/StorageTableFunction.h ================================================================================ --- uncovered block 136-136 --- 134 | if (!blocksHaveEqualStructure(actual_structure, cached_structure) && add_conversion) 135 | { >> 136 | throw Exception(ErrorCodes::INCOMPATIBLE_COLUMNS, "Source storage and table function have different structure"); 137 | } 138 | return storage->write(query, metadata_snapshot, context, async_insert); ================================================================================ src/Storages/StorageTimeSeries.cpp ================================================================================ --- uncovered block 411-415 --- 409 | for (auto target_kind : getTargetKinds()) 410 | { >> 411 | if (isInnerTable(target_kind)) 412 | { >> 413 | auto inner_table = getTargetTable(target_kind, local_context); >> 414 | const auto inner_metadata = inner_table->getInMemoryMetadataPtr(local_context, false); >> 415 | optimized |= inner_table->optimize(query, inner_metadata, partition, final, deduplicate, deduplicate_by_columns, cleanup, local_context); 416 | } 417 | } ================================================================================ 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/StorageSystemColumns.cpp ================================================================================ --- uncovered block 155-155 --- 153 | { 154 | // Table was dropped while acquiring the lock, skipping table >> 155 | continue; 156 | } 157 | ================================================================================ src/Storages/System/StorageSystemCompletions.cpp ================================================================================ --- uncovered block 89-89 --- 87 | auto table_lock = table->tryLockForShare(context->getCurrentQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]); 88 | if (table_lock == nullptr) >> 89 | return; // table was dropped while acquiring the lock 90 | 91 | const auto snapshot = table->getInMemoryMetadataPtr(context, false); ================================================================================ src/Storages/System/StorageSystemConstraints.cpp ================================================================================ --- uncovered block 91-91 --- 89 | const auto metadata_snapshot = table->getInMemoryMetadataPtr(context, false); 90 | if (!metadata_snapshot) >> 91 | return; 92 | const auto & constraints = metadata_snapshot->getConstraints(); 93 | if (constraints.empty()) ================================================================================ src/Storages/System/StorageSystemDataSkippingIndices.cpp ================================================================================ --- uncovered block 123-126 --- 121 | const auto table = tables_it->table(); 122 | if (!table) >> 123 | continue; 124 | const auto metadata_snapshot = table->getInMemoryMetadataPtr(context, false); 125 | if (!metadata_snapshot) >> 126 | continue; 127 | const auto indices = metadata_snapshot->getSecondaryIndices(); 128 | ================================================================================ 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/System/StorageSystemPartsColumns.cpp ================================================================================ --- uncovered block 157-157 --- 155 | 156 | if (columns_mask[src_index++]) >> 157 | columns[res_index++]->insert(part->partition.serializeToString(part_metadata_snapshot)); 158 | if (columns_mask[src_index++]) 159 | columns[res_index++]->insert(part->name); ================================================================================ src/Storages/System/StorageSystemProjectionPartsColumns.cpp ================================================================================ --- uncovered block 109-114 --- 107 | for (size_t part_number = 0; part_number < all_parts.projection_parts.size(); ++part_number) 108 | { >> 109 | const auto & part = all_parts.projection_parts[part_number]; >> 110 | const auto * parent_part = part->getParentPart(); >> 111 | const auto part_metadata_snapshot = part->getMetadataSnapshot(); >> 112 | chassert(parent_part); 113 | >> 114 | auto part_state = all_parts_state[part_number]; 115 | auto columns_size = part->getTotalColumnsSize(); 116 | auto parent_columns_size = parent_part->getTotalColumnsSize(); --- uncovered block 134-140 --- 132 | { 133 | ++column_position; >> 134 | size_t src_index = 0; >> 135 | size_t res_index = 0; >> 136 | if (columns_mask[src_index++]) >> 137 | columns[res_index++]->insert(part->partition.serializeToString(part_metadata_snapshot)); >> 138 | if (columns_mask[src_index++]) >> 139 | columns[res_index++]->insert(part->name); >> 140 | if (columns_mask[src_index++]) 141 | columns[res_index++]->insert(part->getTypeName()); 142 | if (columns_mask[src_index++]) ================================================================================ src/Storages/System/StorageSystemProjections.cpp ================================================================================ --- uncovered block 125-128 --- 123 | const auto table = tables_it->table(); 124 | if (!table) >> 125 | continue; 126 | const auto metadata_snapshot = table->getInMemoryMetadataPtr(context, false); 127 | if (!metadata_snapshot) >> 128 | continue; 129 | const auto & projections = metadata_snapshot->getProjections(); 130 | ================================================================================ src/Storages/System/StorageSystemTables.cpp ================================================================================ --- uncovered block 312-312 --- 310 | if (!metadata_snapshot) 311 | { >> 312 | columns[res_index++]->insertDefault(); 313 | return; 314 | } ================================================================================ src/Storages/TimeSeries/PrometheusRemoteWriteProtocol.cpp ================================================================================ --- uncovered block 669-675 --- 667 | auto time_series_storage_id = time_series_storage->getStorageID(); 668 | >> 669 | LOG_TRACE(log, "{}: Writing {} metrics metadata", >> 670 | time_series_storage_id.getNameForLogs(), metrics_metadata.size()); 671 | >> 672 | auto metrics_table_metadata_ptr = time_series_storage->getTargetTable(ViewTarget::Metrics, getContext())->getInMemoryMetadataPtr(getContext(), false); >> 673 | const auto & metrics_table_metadata = *metrics_table_metadata_ptr; >> 674 | auto blocks = toBlocks(metrics_metadata, metrics_table_metadata); >> 675 | insertToTargetTables(std::move(blocks), *time_series_storage, getContext(), log.get()); 676 | 677 | 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 480-486 --- 478 | AlterLockHolder &) 479 | { >> 480 | throwIfWindowViewIsDisabled(local_context); >> 481 | auto table_id = getStorageID(); >> 482 | auto current_metadata = getInMemoryMetadataPtr(local_context, false); >> 483 | StorageInMemoryMetadata new_metadata = *current_metadata; >> 484 | params.apply(new_metadata, local_context); 485 | >> 486 | const auto & new_select = new_metadata.select; 487 | const auto & new_select_query = new_metadata.select.inner_query; 488 | --- uncovered block 551-562 --- 549 | { 550 | throwIfWindowViewIsDisabled(); >> 551 | UInt32 w_start = addTime(watermark, window_kind, -window_num_units, *time_zone); 552 | >> 553 | auto inner_table = getInnerTable(); >> 554 | const auto inner_table_metadata = inner_table->getInMemoryMetadataPtr(getContext(), false); >> 555 | InterpreterSelectQuery fetch( >> 556 | inner_fetch_query, >> 557 | getContext(), >> 558 | inner_table, >> 559 | inner_table_metadata, >> 560 | SelectQueryOptions(QueryProcessingStage::FetchColumns)); 561 | >> 562 | auto builder = fetch.buildQueryPipeline(); 563 | 564 | ASTPtr filter_function; --- uncovered block 645-655 --- 643 | }; 644 | >> 645 | TemporaryTableHolder blocks_storage(getContext(), creator); 646 | >> 647 | const auto blocks_storage_metadata = blocks_storage.getTable()->getInMemoryMetadataPtr(getContext(), false); >> 648 | InterpreterSelectQuery select( >> 649 | getFinalQuery(), >> 650 | getContext(), >> 651 | blocks_storage.getTable(), >> 652 | blocks_storage_metadata, >> 653 | SelectQueryOptions(QueryProcessingStage::Complete)); 654 | >> 655 | builder = select.buildQueryPipeline(); 656 | 657 | builder.addSimpleTransform( --- uncovered block 727-736 --- 725 | auto block_io = interpreter.execute(); 726 | >> 727 | auto pipe = Pipe(std::make_shared(blocks, std::make_shared(std::move(header)))); 728 | >> 729 | auto target_metadata_snapshot = getTargetTable()->getInMemoryMetadataPtr(context, false); >> 730 | auto adding_missing_defaults_dag = addMissingDefaults( >> 731 | pipe.getHeader(), >> 732 | block_io.pipeline.getHeader().getNamesAndTypesList(), >> 733 | target_metadata_snapshot->getColumns(), >> 734 | context, >> 735 | context->getSettingsRef()[Setting::insert_null_as_default]); >> 736 | auto adding_missing_defaults_actions = std::make_shared(std::move(adding_missing_defaults_dag)); 737 | pipe.addSimpleTransform([&](const SharedHeader & stream_header) 738 | { --- uncovered block 1607-1617 --- 1605 | return StorageBlocks::createStorage(blocks_id_global, required_columns, std::move(pipes), QueryProcessingStage::FetchColumns); 1606 | }; >> 1607 | TemporaryTableHolder blocks_storage(local_context, creator); 1608 | >> 1609 | const auto blocks_storage_metadata = blocks_storage.getTable()->getInMemoryMetadataPtr(local_context, false); >> 1610 | InterpreterSelectQuery select_block( >> 1611 | window_view.getMergeableQuery(), >> 1612 | local_context, >> 1613 | blocks_storage.getTable(), >> 1614 | blocks_storage_metadata, >> 1615 | QueryProcessingStage::WithMergeableState); 1616 | >> 1617 | builder = select_block.buildQueryPipeline(); 1618 | 1619 | builder.addSimpleTransform( ================================================================================ 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 114-114 --- 112 | const auto * merge_tree = dynamic_cast(source_table_ptr.get()); 113 | if (!merge_tree) >> 114 | throw Exception(ErrorCodes::BAD_ARGUMENTS, "Storage MergeTreeTextIndex expected MergeTree table, got: {}", source_table_ptr->getName()); 115 | 116 | auto text_index = MergeTreeIndexFactory::instance().get(metadata_snapshot, index_desc, *merge_tree->getSettings()); === Lost Baseline Coverage: 70 lines === ================================================================================ src/Interpreters/Context.cpp ================================================================================ --- lost coverage block 6179-6179 --- 6177 | 6178 | if (!shared->system_logs) >> 6179 | return {}; 6180 | 6181 | return shared->system_logs->asynchronous_metric_log; ================================================================================ src/Storages/MergeTree/MergeTreeData.cpp ================================================================================ --- lost coverage block 9197-9206 --- 9195 | else if (block.has(name)) 9196 | res.insert(block.getByName(name)); >> 9197 | else if (startsWith(name, "count")) // special case to match count(...) variants 9198 | { 9199 | const auto & column = block.getByName("count()"); 9200 | res.insert({column.column, column.type, name}); 9201 | } 9202 | else >> 9203 | throw Exception( 9204 | ErrorCodes::LOGICAL_ERROR, >> 9205 | "Cannot find column {} in minmax_count projection but query analysis still selects this projection. It's a bug", >> 9206 | name); 9207 | } 9208 | --- lost coverage block 9630-9630 --- 9628 | broken_part_callback(data_part->name); 9629 | else >> 9630 | LOG_DEBUG(log, "Will not check potentially broken part {} because it's not active", data_part->getNameWithState()); 9631 | } 9632 | --- lost coverage block 10871-10871 --- 10869 | 10870 | if (!query_context->getSettingsRef()[Setting::enable_shared_storage_snapshot_in_query]) >> 10871 | return IStorage::getInMemoryMetadataPtr(query_context, bypass_metadata_cache); 10872 | 10873 | auto [cache, lock] = query_context->getQueryMetadataCache()->getStorageMetadataCache(); ================================================================================ src/Storages/MergeTree/MergeTreeDataPartWide.cpp ================================================================================ --- lost coverage block 453-453 --- 451 | else 452 | { >> 453 | if (!cols_substreams.empty()) 454 | { 455 | /// Use columns_substreams.txt as the source of truth. --- lost coverage block 488-491 --- 486 | { 487 | /// Fallback: check that all marks are nonempty and have the same size. >> 488 | ISerialization::EnumerateStreamsSettings settings; >> 489 | settings.enumerate_dynamic_streams = false; >> 490 | std::optional marks_size; >> 491 | for (const auto & name_type : columns) 492 | { 493 | auto serialization = getSerialization(name_type.name); --- lost coverage block 581-581 --- 579 | filename = getStreamNameForColumn(column, substream_path, DATA_FILE_EXTENSION, checksums, storage.getSettings()); 580 | else >> 581 | filename = getStreamNameForColumn(column, substream_path, DATA_FILE_EXTENSION, getDataPartStorage(), storage.getSettings()); 582 | } 583 | }); ================================================================================ src/Storages/MergeTree/MergeTreeIndexBloomFilterText.cpp ================================================================================ --- lost coverage block 754-754 --- 752 | } 753 | >> 754 | return false; 755 | } 756 | ================================================================================ src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp ================================================================================ --- lost coverage block 234-237 --- 232 | else 233 | { >> 234 | throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, >> 235 | "It seems you have upgraded from a version earlier than 20.4 straight to one later than 24.10. " >> 236 | "ClickHouse does not support upgrades that span more than a year. " >> 237 | "Please update gradually (through intermediate versions)."); 238 | } 239 | --- lost coverage block 363-377 --- 361 | catch (const Coordination::Exception & e) 362 | { >> 363 | String existing_replica_host; >> 364 | zookeeper->tryGet(fs::path(storage.replica_path) / "host", existing_replica_host); 365 | >> 366 | if (existing_replica_host.empty()) 367 | existing_replica_host = "without host node"; 368 | else >> 369 | boost::replace_all(existing_replica_host, "\n", ", "); 370 | >> 371 | if (e.code == Coordination::Error::ZNODEEXISTS) 372 | throw Exception(ErrorCodes::REPLICA_IS_ALREADY_ACTIVE, 373 | "Replica {} appears to be already active ({}). If you're sure it's not, " 374 | "try again in a minute or remove znode {}/is_active manually", 375 | storage.replica_path, existing_replica_host, storage.replica_path); 376 | >> 377 | throw; 378 | } 379 | --- lost coverage block 489-507 --- 487 | } 488 | >> 489 | const Coordination::Requests ops = { >> 490 | zkutil::makeSetRequest(fs::path(replica_path) / "metadata_version", std::to_string(table_stat.version), replica_stat.version), >> 491 | zkutil::makeCheckRequest(fs::path(zookeeper_path) / "metadata", table_stat.version), 492 | }; >> 493 | Coordination::Responses ops_responses; >> 494 | const Coordination::Error code = zookeeper->tryMulti(ops, ops_responses); >> 495 | if (code == Coordination::Error::ZOK) 496 | { 497 | LOG_DEBUG(log, "Successfully set metadata_version to {}", table_stat.version); 498 | return table_stat.version; 499 | } 500 | >> 501 | if (code == Coordination::Error::ZBADVERSION) 502 | { 503 | LOG_WARNING(log, "Cannot fix metadata_version because either metadata.version or metadata_version.version changed, attempts left = {}", num_attempts - attempt - 1); 504 | continue; 505 | } 506 | >> 507 | throw zkutil::KeeperException(code); 508 | } 509 | ================================================================================ src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp ================================================================================ --- lost coverage block 1018-1018 --- 1016 | else 1017 | { >> 1018 | throw DB::Exception(ErrorCodes::ROCKSDB_ERROR, "rocksdb error {}", statuses[i].ToString()); 1019 | } 1020 | } ================================================================================ src/Storages/StorageKeeperMap.cpp ================================================================================ --- lost coverage block 1538-1538 --- 1536 | else 1537 | { >> 1538 | throw DB::Exception(ErrorCodes::KEEPER_EXCEPTION, "Failed to fetch value: {}", code); 1539 | } 1540 | } ================================================================================ src/Storages/StorageMergeTree.cpp ================================================================================ --- lost coverage block 1827-1827 --- 1825 | { 1826 | if (is_cancelled(mutate_entry)) >> 1827 | return false; 1828 | 1829 | /// We take new metadata snapshot here. It's because mutation commands can be executed only with metadata snapshot ================================================================================ src/Storages/StorageReplicatedMergeTree.cpp ================================================================================ --- lost coverage block 1605-1606 --- 1603 | if (code == Coordination::Error::ZNOTEMPTY) 1604 | { >> 1605 | LOG_WARNING(logger, "Another replica was suddenly created, will keep the table {}", remote_replica_path); >> 1606 | return false; 1607 | } 1608 | if (code != Coordination::Error::ZOK) --- lost coverage block 2785-2785 --- 2783 | /* try_fetch_shared= */ true)) 2784 | { >> 2785 | return false; 2786 | } 2787 | } --- lost coverage block 3262-3263 --- 3260 | continue; 3261 | >> 3262 | MergeTreePartInfo covering_drop_range; >> 3263 | if (queue.isGoingToBeDropped(part_desc->new_part_info, &covering_drop_range)) 3264 | { 3265 | LOG_WARNING(log, "Will not add part {} (while replacing {}) because it's going to be dropped (DROP_RANGE: {})", --- lost coverage block 3274-3278 --- 3272 | /// However, it's quite dangerous, because part may appear in source table. 3273 | /// So we enqueue it for check only if no replicas of source table have part either. >> 3274 | bool need_check = true; >> 3275 | if (auto * replicated_src_table = typeid_cast(source_table.get())) 3276 | { >> 3277 | String src_replica = replicated_src_table->findReplicaHavingPart(part_desc->src_part_name, false); >> 3278 | if (!src_replica.empty()) 3279 | { 3280 | LOG_DEBUG(log, "Found part {} on replica {} of source table, will not check part {} required for {}", --- lost coverage block 3286-3295 --- 3284 | } 3285 | >> 3286 | if (need_check) 3287 | { >> 3288 | LOG_DEBUG(log, "Will check part {} required for {}, because no replicas have it (including replicas of source table)", >> 3289 | part_desc->new_part_name, entry.znode_name); >> 3290 | enqueuePartForCheck(part_desc->new_part_name); 3291 | } 3292 | >> 3293 | throw Exception(ErrorCodes::NO_REPLICA_HAS_PART, >> 3294 | "Not found part {} (or part covering it) neither source table neither remote replicas", >> 3295 | part_desc->new_part_name); 3296 | } 3297 | --- lost coverage block 4372-4373 --- 4370 | /// Note that we need to check shutdown_prepared_called, not shutdown_called, since the table will be marked as readonly 4371 | /// after calling StorageReplicatedMergeTree::flushAndPrepareForShutdown(). >> 4372 | if (shutdown_prepared_called) >> 4373 | return AttemptStatus::CannotSelect; 4374 | throw Exception(ErrorCodes::TABLE_IS_READ_ONLY, "Table is in readonly mode (replica path: {}), cannot assign new merges", replica_path); 4375 | } --- lost coverage block 5470-5473 --- 5468 | if (auto part = getPartIfExists(part_info, {MergeTreeDataPartState::Outdated, MergeTreeDataPartState::Deleting})) 5469 | { >> 5470 | LOG_DEBUG(log, "Part {} should be deleted after previous attempt before fetch", part->name); 5471 | /// Force immediate parts cleanup to delete the part that was left from the previous fetch attempt. >> 5472 | cleanup_thread.wakeup(); >> 5473 | return false; 5474 | } 5475 | } --- lost coverage block 5544-5555 --- 5542 | else 5543 | { >> 5544 | String columns_str; >> 5545 | String checksums_str; 5546 | >> 5547 | if (zookeeper->tryGet(fs::path(part_path) / "columns", columns_str) && >> 5548 | zookeeper->tryGet(fs::path(part_path) / "checksums", checksums_str)) 5549 | { 5550 | desired_part_header = ReplicatedMergeTreePartHeader::fromColumnsAndChecksumsZNodes(columns_str, checksums_str); 5551 | } 5552 | else 5553 | { >> 5554 | LOG_INFO(log, "Not checking checksums of part {} with replica {}:{} because part was removed from ZooKeeper", >> 5555 | part_name, source_zookeeper_name, source_replica_path); 5556 | } 5557 | } --- lost coverage block 8834-8838 --- 8832 | else 8833 | { >> 8834 | if (parts_should_be_retried) 8835 | parts_should_be_retried->insert(part_names[i]); 8836 | >> 8837 | if (!Coordination::isHardwareError(response.error)) >> 8838 | LOG_WARNING(log, "Cannot remove part {} from ZooKeeper: {}", part_names[i], Coordination::errorMessage(response.error)); 8839 | } 8840 | } --- lost coverage block 9867-9869 --- 9865 | if (partial_shutdown_called) 9866 | { >> 9867 | was_interrupted = true; >> 9868 | target_entry_event.set(); >> 9869 | return; 9870 | } 9871 | --- lost coverage block 9893-9893 --- 9891 | 9892 | if (was_interrupted) >> 9893 | throw Exception(ErrorCodes::ABORTED, "Shutdown is called for table"); 9894 | 9895 | return true; ================================================================================ src/TableFunctions/TableFunctionLoop.cpp ================================================================================ --- lost coverage block 81-81 --- 79 | else 80 | { >> 81 | throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Expected identifier or function for argument 1 of function 'loop', got {}", args[0]->getID()); 82 | } 83 | } WARNING: Failed to get start time for [Print Uncovered Code] - start time and duration won't be set --- Coverage counts --- Lines : baseline 834,224/978,674 -> current 833,782/978,861 (delta -442 / +187) Functions : baseline 928,938/1,003,687 -> current 928,876/1,003,698 (delta -62 / +11) Branches : baseline 265,634/343,012 -> current 265,537/343,012 (delta -97 / +0)