duckdb 0.8.1-dev0.0 → 0.8.1-dev111.0

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -58,7 +58,7 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	auto current_time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 
 	auto proto = CreateThriftProtocol(allocator, file_handle, false);
-	auto &transport = ((ThriftFileTransport &)*proto->getTransport());
+	auto &transport = reinterpret_cast<ThriftFileTransport &>(*proto->getTransport());
 	auto file_size = transport.GetSize();
 	if (file_size < 12) {
 		throw InvalidInputException("File '%s' too small to be a Parquet file", file_handle.path);
@@ -71,11 +71,11 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	transport.SetLocation(file_size - 8);
 	transport.read((uint8_t *)buf.ptr, 8);
 
-	if (strncmp(buf.ptr + 4, "PAR1", 4) != 0) {
+	if (memcmp(buf.ptr + 4, "PAR1", 4) != 0) {
 		throw InvalidInputException("No magic bytes found at end of file '%s'", file_handle.path);
 	}
 	// read four-byte footer length from just before the end magic bytes
-	auto footer_len = *(uint32_t *)buf.ptr;
+	auto footer_len = *reinterpret_cast<uint32_t *>(buf.ptr);
 	if (footer_len <= 0 || file_size < 12 + footer_len) {
 		throw InvalidInputException("Footer length error in file '%s'", file_handle.path);
 	}
@@ -484,7 +484,7 @@ unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(const string &name) {
 	unique_ptr<BaseStatistics> column_stats;
 	auto file_meta_data = GetFileMetadata();
 	auto root_reader = CreateReader();
-	auto column_reader = ((StructColumnReader *)root_reader.get())->GetChildReader(file_col_idx);
+	auto column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
 
 	for (idx_t row_group_idx = 0; row_group_idx < file_meta_data->row_groups.size(); row_group_idx++) {
 		auto &row_group = file_meta_data->row_groups[row_group_idx];
@@ -573,7 +573,7 @@ idx_t ParquetReader::GetGroupOffset(ParquetReaderScanState &state) {
 void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t col_idx) {
 	auto &group = GetGroup(state);
 	auto column_id = reader_data.column_ids[col_idx];
-	auto column_reader = ((StructColumnReader *)state.root_reader.get())->GetChildReader(column_id);
+	auto column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
 
 	// TODO move this to columnreader too
 	if (reader_data.filters) {
@@ -760,14 +760,14 @@ static void FilterOperationSwitch(Vector &v, Value &constant, parquet_filter_t &
 static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter_mask, idx_t count) {
 	switch (filter.filter_type) {
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction = (ConjunctionAndFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction.child_filters) {
 			ApplyFilter(v, *child_filter, filter_mask, count);
 		}
 		break;
 	}
 	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction = (ConjunctionOrFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionOrFilter>();
 		parquet_filter_t or_mask;
 		for (auto &child_filter : conjunction.child_filters) {
 			parquet_filter_t child_mask = filter_mask;
@@ -778,7 +778,7 @@ static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter
 		break;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		switch (constant_filter.comparison_type) {
 		case ExpressionType::COMPARE_EQUAL:
 			FilterOperationSwitch<Equals>(v, constant_filter.constant, filter_mask, count);
@@ -831,7 +831,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		state.current_group++;
 		state.group_offset = 0;
 
-		auto &trans = (ThriftFileTransport &)*state.thrift_file_proto->getTransport();
+		auto &trans = reinterpret_cast<ThriftFileTransport &>(*state.thrift_file_proto->getTransport());
 		trans.ClearPrefetch();
 		state.current_group_prefetched = false;
 
@@ -846,8 +846,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 
 			auto file_col_idx = reader_data.column_ids[col_idx];
 
-			auto root_reader = ((StructColumnReader *)state.root_reader.get());
-			to_scan_compressed_bytes += root_reader->GetChildReader(file_col_idx)->TotalCompressedSize();
+			auto &root_reader = state.root_reader->Cast<StructColumnReader>();
+			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx)->TotalCompressedSize();
 		}
 
 		auto &group = GetGroup(state);
@@ -880,14 +880,14 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				// Prefetch column-wise
 				for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 					auto file_col_idx = reader_data.column_ids[col_idx];
-					auto root_reader = ((StructColumnReader *)state.root_reader.get());
+					auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 					bool has_filter = false;
 					if (reader_data.filters) {
 						auto entry = reader_data.filters->filters.find(reader_data.column_mapping[col_idx]);
 						has_filter = entry != reader_data.filters->filters.end();
 					}
-					root_reader->GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
+					root_reader.GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
 				}
 
 				trans.FinalizeRegistration();
@@ -924,7 +924,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 	auto define_ptr = (uint8_t *)state.define_buf.ptr;
 	auto repeat_ptr = (uint8_t *)state.repeat_buf.ptr;
 
-	auto root_reader = ((StructColumnReader *)state.root_reader.get());
+	auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 	if (reader_data.filters) {
 		vector<bool> need_to_read(reader_data.column_ids.size(), true);
@@ -947,7 +947,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				auto result_idx = reader_data.column_mapping[id];
 
 				auto &result_vector = result.data[result_idx];
-				auto child_reader = root_reader->GetChildReader(file_col_idx);
+				auto child_reader = root_reader.GetChildReader(file_col_idx);
 				child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 				need_to_read[id] = false;
 
@@ -962,11 +962,11 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 			}
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			if (filter_mask.none()) {
-				root_reader->GetChildReader(file_col_idx)->Skip(result.size());
+				root_reader.GetChildReader(file_col_idx)->Skip(result.size());
 				continue;
 			}
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 		}
 
@@ -982,7 +982,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			auto rows_read = child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 			if (rows_read != result.size()) {
 				throw InvalidInputException("Mismatch in parquet read for column %llu, expected %llu rows, got %llu",

package/src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -48,12 +48,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 	if (stats.empty()) {
 		return Value();
 	}
+	auto stats_data = const_data_ptr_cast(stats.c_str());
 	switch (type.id()) {
 	case LogicalTypeId::BOOLEAN: {
 		if (stats.size() != sizeof(bool)) {
 			throw InternalException("Incorrect stats size for type BOOLEAN");
 		}
-		return Value::BOOLEAN(Load<bool>((data_ptr_t)stats.c_str()));
+		return Value::BOOLEAN(Load<bool>(stats_data));
 	}
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
@@ -61,29 +62,29 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(uint32_t)) {
 			throw InternalException("Incorrect stats size for type UINTEGER");
 		}
-		return Value::UINTEGER(Load<uint32_t>((data_ptr_t)stats.c_str()));
+		return Value::UINTEGER(Load<uint32_t>(stats_data));
 	case LogicalTypeId::UBIGINT:
 		if (stats.size() != sizeof(uint64_t)) {
 			throw InternalException("Incorrect stats size for type UBIGINT");
 		}
-		return Value::UBIGINT(Load<uint64_t>((data_ptr_t)stats.c_str()));
+		return Value::UBIGINT(Load<uint64_t>(stats_data));
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type INTEGER");
 		}
-		return Value::INTEGER(Load<int32_t>((data_ptr_t)stats.c_str()));
+		return Value::INTEGER(Load<int32_t>(stats_data));
 	case LogicalTypeId::BIGINT:
 		if (stats.size() != sizeof(int64_t)) {
 			throw InternalException("Incorrect stats size for type BIGINT");
 		}
-		return Value::BIGINT(Load<int64_t>((data_ptr_t)stats.c_str()));
+		return Value::BIGINT(Load<int64_t>(stats_data));
 	case LogicalTypeId::FLOAT: {
 		if (stats.size() != sizeof(float)) {
 			throw InternalException("Incorrect stats size for type FLOAT");
 		}
-		auto val = Load<float>((data_ptr_t)stats.c_str());
+		auto val = Load<float>(stats_data);
 		if (!Value::FloatIsFinite(val)) {
 			return Value();
 		}
@@ -93,7 +94,7 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(double)) {
 			throw InternalException("Incorrect stats size for type DOUBLE");
 		}
-		auto val = Load<double>((data_ptr_t)stats.c_str());
+		auto val = Load<double>(stats_data);
 		if (!Value::DoubleIsFinite(val)) {
 			return Value();
 		}
@@ -107,13 +108,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(int32_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int32_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int32_t>(stats_data), width, scale);
 		}
 		case Type::INT64: {
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int64_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int64_t>(stats_data), width, scale);
 		}
 		case Type::BYTE_ARRAY:
 		case Type::FIXED_LEN_BYTE_ARRAY:
@@ -122,21 +123,17 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			}
 			switch (type.InternalType()) {
 			case PhysicalType::INT16:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int16_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int16_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT32:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int32_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int32_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT64:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int64_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int64_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT128:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<hugeint_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<hugeint_t>(stats_data, stats.size()), width,
+				                      scale);
 			default:
 				throw InternalException("Unsupported internal type for decimal");
 			}
@@ -155,14 +152,14 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type DATE");
 		}
-		return Value::DATE(date_t(Load<int32_t>((data_ptr_t)stats.c_str())));
+		return Value::DATE(date_t(Load<int32_t>(stats_data)));
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ: {
 		int64_t val;
 		if (stats.size() == sizeof(int32_t)) {
-			val = Load<int32_t>((data_ptr_t)stats.c_str());
+			val = Load<int32_t>(stats_data);
 		} else if (stats.size() == sizeof(int64_t)) {
-			val = Load<int64_t>((data_ptr_t)stats.c_str());
+			val = Load<int64_t>(stats_data);
 		} else {
 			throw InternalException("Incorrect stats size for type TIME");
 		}
@@ -190,13 +187,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(Int96)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>((data_ptr_t)stats.c_str())));
+			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>(stats_data)));
 		} else {
 			D_ASSERT(schema_ele.type == Type::INT64);
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			auto val = Load<int64_t>((data_ptr_t)stats.c_str());
+			auto val = Load<int64_t>(stats_data);
 			if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIMESTAMP) {
 				// logical type
 				if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {

package/src/duckdb/extension/parquet/parquet_timestamp.cpp

@@ -17,7 +17,7 @@ static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
 
 static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
 	int64_t days_since_epoch = impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
-	auto nanoseconds = Load<int64_t>((data_ptr_t)impala_timestamp.value);
+	auto nanoseconds = Load<int64_t>(const_data_ptr_cast(impala_timestamp.value));
 	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
 	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
 }
@@ -35,7 +35,7 @@ Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 	// first two uint32 in Int96 are nanoseconds since midnights
 	// last uint32 is number of days since year 4713 BC ("Julian date")
 	Int96 impala_ts;
-	Store<uint64_t>(ms_since_midnight * 1000000, (data_ptr_t)impala_ts.value);
+	Store<uint64_t>(ms_since_midnight * 1000000, data_ptr_cast(impala_ts.value));
 	impala_ts.value[2] = days_since_epoch + JULIAN_TO_UNIX_EPOCH_DAYS;
 	return impala_ts;
 }

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -45,7 +45,7 @@ public:
 	}
 
 	void write_virt(const uint8_t *buf, uint32_t len) override {
-		serializer.WriteData((const_data_ptr_t)buf, len);
+		serializer.WriteData(const_data_ptr_cast(buf), len);
 	}
 
 private:
@@ -232,7 +232,7 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, vector<LogicalT
 	writer = make_uniq<BufferedFileWriter>(fs, file_name.c_str(),
 	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
 	// parquet files start with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 	TCompactProtocolFactoryT<MyTransport> tproto_factory;
 	protocol = tproto_factory.getProtocol(make_shared<MyTransport>(*writer));
 
@@ -327,7 +327,7 @@ void ParquetWriter::Finalize() {
 	writer->Write<uint32_t>(writer->GetTotalWritten() - start_offset);
 
 	// parquet files also end with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 
 	// flush to disk
 	writer->Sync();

package/src/duckdb/extension/parquet/zstd_file_system.cpp

@@ -61,9 +61,9 @@ bool ZstdStreamWrapper::Read(StreamData &sd) {
 		throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
 	}
 
-	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;
-	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;
-	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos;
+	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;  // NOLINT
+	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;   // NOLINT
+	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos; // NOLINT
 	return false;
 }
 

package/src/duckdb/src/catalog/catalog.cpp

@@ -532,10 +532,6 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
-		auto catalog_name = GetName();
-		if (catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
-			catalog_name = INVALID_CATALOG;
-		}
 		auto entries = GetCatalogEntries(context, GetName(), INVALID_SCHEMA);
 		for (auto &entry : entries) {
 			auto &candidate_schema = entry.schema;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -206,6 +206,7 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 	return constraints;
 }
 
+// LCOV_EXCL_START
 DataTable &TableCatalogEntry::GetStorage() {
 	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
@@ -213,4 +214,6 @@ DataTable &TableCatalogEntry::GetStorage() {
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
 	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
+// LCOV_EXCL_STOP
+
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -34,10 +34,6 @@ unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
-// LCOV_EXCL_STOP
-
-void CatalogEntry::Verify(Catalog &catalog_p) {
-}
 
 Catalog &CatalogEntry::ParentCatalog() {
 	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
@@ -46,6 +42,10 @@ Catalog &CatalogEntry::ParentCatalog() {
 SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
 }
+// LCOV_EXCL_STOP
+
+void CatalogEntry::Verify(Catalog &catalog_p) {
+}
 
 InCatalogEntry::InCatalogEntry(CatalogType type, Catalog &catalog, string name)
     : CatalogEntry(type, catalog, std::move(name)), catalog(catalog) {

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -42,7 +42,7 @@ private:
 };
 
 CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
-    : catalog((DuckCatalog &)catalog_p), defaults(std::move(defaults)) {
+    : catalog(catalog_p.Cast<DuckCatalog>()), defaults(std::move(defaults)) {
 	D_ASSERT(catalog_p.IsDuckCatalog());
 }
 CatalogSet::~CatalogSet() {

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -220,8 +220,8 @@ void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntr
 	// Emplace guarantees that the same object cannot be inserted twice in the unordered_set
 	// In the case AddOwnership is called twice, because of emplace, the object will not be repeated in the set.
 	// We use an automatic dependency because if the Owner gets deleted, then the owned objects are also deleted
-	dependents_map[owner].emplace(Dependency(entry, DependencyType::DEPENDENCY_OWNS));
-	dependents_map[entry].emplace(Dependency(owner, DependencyType::DEPENDENCY_OWNED_BY));
+	dependents_map[owner].emplace(entry, DependencyType::DEPENDENCY_OWNS);
+	dependents_map[entry].emplace(owner, DependencyType::DEPENDENCY_OWNED_BY);
 	dependencies_map[owner].emplace(entry);
 }
 

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -142,6 +142,7 @@ string DuckCatalog::GetDBPath() {
 
 void DuckCatalog::Verify() {
 #ifdef DEBUG
+	Catalog::Verify();
 	schemas->Verify(*this);
 #endif
 }