duckdb 0.7.2-dev1803.0 → 0.7.2-dev1867.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev1803.0",
+  "version": "0.7.2-dev1867.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -111,14 +111,14 @@ CatalogEntry *Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTabl
 	return CreateTable(context, bound_info.get());
 }
 
-CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                    BoundCreateTableInfo *info) {
-	return schema->CreateTable(transaction, info);
+	return schema.CreateTable(transaction, info);
 }
 
 CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) {
 	auto schema = GetSchema(transaction, info->base->schema);
-	return CreateTable(transaction, schema, info);
+	return CreateTable(transaction, *schema, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -126,15 +126,15 @@ CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTa
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateView(transaction, schema, info);
+	return CreateView(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateView(ClientContext &context, CreateViewInfo *info) {
 	return CreateView(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry *schema, CreateViewInfo *info) {
-	return schema->CreateView(transaction, info);
+CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateViewInfo *info) {
+	return schema.CreateView(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -142,16 +142,16 @@ CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogE
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateSequence(transaction, schema, info);
+	return CreateSequence(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
 	return CreateSequence(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                       CreateSequenceInfo *info) {
-	return schema->CreateSequence(transaction, info);
+	return schema.CreateSequence(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -159,15 +159,15 @@ CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCata
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateType(transaction, schema, info);
+	return CreateType(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateType(ClientContext &context, CreateTypeInfo *info) {
 	return CreateType(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry *schema, CreateTypeInfo *info) {
-	return schema->CreateType(transaction, info);
+CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTypeInfo *info) {
+	return schema.CreateType(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -175,16 +175,16 @@ CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogE
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateTableFunction(transaction, schema, info);
+	return CreateTableFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
 	return CreateTableFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                            CreateTableFunctionInfo *info) {
-	return schema->CreateTableFunction(transaction, info);
+	return schema.CreateTableFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -192,16 +192,16 @@ CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, Schem
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateCopyFunction(transaction, schema, info);
+	return CreateCopyFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
 	return CreateCopyFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                           CreateCopyFunctionInfo *info) {
-	return schema->CreateCopyFunction(transaction, info);
+	return schema.CreateCopyFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -209,16 +209,16 @@ CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, Schema
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreatePragmaFunction(transaction, schema, info);
+	return CreatePragmaFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
 	return CreatePragmaFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                             CreatePragmaFunctionInfo *info) {
-	return schema->CreatePragmaFunction(transaction, info);
+	return schema.CreatePragmaFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -226,16 +226,16 @@ CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, Sche
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateFunction(transaction, schema, info);
+	return CreateFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
 	return CreateFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                       CreateFunctionInfo *info) {
-	return schema->CreateFunction(transaction, info);
+	return schema.CreateFunction(transaction, info);
 }
 
 CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
@@ -248,16 +248,16 @@ CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *i
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateCollation(transaction, schema, info);
+	return CreateCollation(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
 	return CreateCollation(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                        CreateCollationInfo *info) {
-	return schema->CreateCollation(transaction, info);
+	return schema.CreateCollation(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -64,10 +64,10 @@ void FindForeignKeyInformation(CatalogEntry &entry, AlterForeignKeyType alter_fk
 
 DuckSchemaEntry::DuckSchemaEntry(Catalog *catalog, string name_p, bool is_internal)
     : SchemaCatalogEntry(catalog, std::move(name_p), is_internal),
-      tables(*catalog, make_uniq<DefaultViewGenerator>(*catalog, this)), indexes(*catalog), table_functions(*catalog),
+      tables(*catalog, make_uniq<DefaultViewGenerator>(*catalog, *this)), indexes(*catalog), table_functions(*catalog),
       copy_functions(*catalog), pragma_functions(*catalog),
-      functions(*catalog, make_uniq<DefaultFunctionGenerator>(*catalog, this)), sequences(*catalog),
-      collations(*catalog), types(*catalog, make_uniq<DefaultTypeGenerator>(*catalog, this)) {
+      functions(*catalog, make_uniq<DefaultFunctionGenerator>(*catalog, *this)), sequences(*catalog),
+      collations(*catalog), types(*catalog, make_uniq<DefaultTypeGenerator>(*catalog, *this)) {
 }
 
 CatalogEntry *DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
@@ -78,7 +78,7 @@ CatalogEntry *DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction,
 
 	// first find the set for this entry
 	auto &set = GetCatalogSet(entry_type);
-	dependencies.AddDependency(this);
+	dependencies.AddDependency(*this);
 	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		// CREATE OR REPLACE: first try to drop the entry
 		auto old_entry = set.GetEntry(transaction, entry_name);
@@ -122,7 +122,7 @@ CatalogEntry *DuckSchemaEntry::CreateTable(CatalogTransaction transaction, Bound
 
 		// make a dependency between this table and referenced table
 		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
-		info->dependencies.AddDependency(set.GetEntry(transaction, fk_info->name));
+		info->dependencies.AddDependency(*set.GetEntry(transaction, fk_info->name));
 	}
 	return entry;
 }
@@ -194,7 +194,7 @@ CatalogEntry *DuckSchemaEntry::CreateView(CatalogTransaction transaction, Create
 
 CatalogEntry *DuckSchemaEntry::CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) {
 	DependencyList dependencies;
-	dependencies.AddDependency(table);
+	dependencies.AddDependency(*table);
 	auto index = make_uniq<DuckIndexEntry>(catalog, this, info);
 	return AddEntryInternal(GetCatalogTransaction(context), std::move(index), info->on_conflict, dependencies);
 }

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

@@ -136,7 +136,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 	value->set = this;
 
 	// now add the dependency set of this object to the dependency manager
-	catalog.GetDependencyManager().AddObject(transaction, value.get(), dependencies);
+	catalog.GetDependencyManager().AddObject(transaction, *value, dependencies);
 
 	auto value_ptr = value.get();
 	EntryIndex entry_index(*this, index);
@@ -196,7 +196,7 @@ bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipI
 		return false;
 	}
 
-	catalog.GetDependencyManager().AddOwnership(transaction, owner_entry, entry);
+	catalog.GetDependencyManager().AddOwnership(transaction, *owner_entry, *entry);
 
 	return true;
 }
@@ -272,7 +272,7 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	// Note that we do this AFTER the new entry has been entirely set up in the catalog set
 	// that is because in case the alter fails because of a dependency conflict, we need to be able to cleanly roll back
 	// to the old entry.
-	catalog.GetDependencyManager().AlterObject(transaction, entry, new_entry);
+	catalog.GetDependencyManager().AlterObject(transaction, *entry, *new_entry);
 
 	return true;
 }
@@ -287,7 +287,7 @@ void CatalogSet::DropEntryDependencies(CatalogTransaction transaction, EntryInde
 
 	// check any dependencies of this object
 	D_ASSERT(entry.catalog->IsDuckCatalog());
-	((DuckCatalog &)*entry.catalog).GetDependencyManager().DropObject(transaction, &entry, cascade);
+	((DuckCatalog &)*entry.catalog).GetDependencyManager().DropObject(transaction, entry, cascade);
 
 	// dropper destructor is called here
 	// the destructor makes sure to return the value to the previous state
@@ -350,7 +350,7 @@ void CatalogSet::CleanupEntry(CatalogEntry *catalog_entry) {
 		if (!catalog_entry->deleted) {
 			// delete the entry from the dependency manager, if it is not deleted yet
 			D_ASSERT(catalog_entry->catalog->IsDuckCatalog());
-			((DuckCatalog &)*catalog_entry->catalog).GetDependencyManager().EraseObject(catalog_entry);
+			((DuckCatalog &)*catalog_entry->catalog).GetDependencyManager().EraseObject(*catalog_entry);
 		}
 		auto parent = catalog_entry->parent;
 		parent->child = std::move(catalog_entry->child);
@@ -547,16 +547,18 @@ void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
 }
 
 void CatalogSet::AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove) {
-	CatalogEntry *user_type_catalog = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
-	if (user_type_catalog) {
-		auto &dependency_manager = catalog.GetDependencyManager();
-		if (remove) {
-			dependency_manager.dependents_map[user_type_catalog].erase(entry.parent);
-			dependency_manager.dependencies_map[entry.parent].erase(user_type_catalog);
-		} else {
-			dependency_manager.dependents_map[user_type_catalog].insert(&entry);
-			dependency_manager.dependencies_map[&entry].insert(user_type_catalog);
-		}
+	CatalogEntry *user_type_catalog_p = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
+	if (!user_type_catalog_p) {
+		return;
+	}
+	auto &user_type_catalog = *user_type_catalog_p;
+	auto &dependency_manager = catalog.GetDependencyManager();
+	if (remove) {
+		dependency_manager.dependents_map[user_type_catalog].erase(*entry.parent);
+		dependency_manager.dependencies_map[*entry.parent].erase(user_type_catalog);
+	} else {
+		dependency_manager.dependents_map[user_type_catalog].insert(entry);
+		dependency_manager.dependencies_map[entry].insert(user_type_catalog);
 	}
 }
 
@@ -613,35 +615,35 @@ void CatalogSet::Undo(CatalogEntry &entry) {
 	// and entry->parent has to be removed ("rolled back")
 
 	// i.e. we have to place (entry) as (entry->parent) again
-	auto &to_be_removed_node = entry.parent;
+	auto &to_be_removed_node = *entry.parent;
 
 	AdjustTableDependencies(entry);
 
-	if (!to_be_removed_node->deleted) {
+	if (!to_be_removed_node.deleted) {
 		// delete the entry from the dependency manager as well
 		auto &dependency_manager = catalog.GetDependencyManager();
 		dependency_manager.EraseObject(to_be_removed_node);
 	}
-	if (entry.name != to_be_removed_node->name) {
+	if (entry.name != to_be_removed_node.name) {
 		// rename: clean up the new name when the rename is rolled back
-		auto removed_entry = mapping.find(to_be_removed_node->name);
+		auto removed_entry = mapping.find(to_be_removed_node.name);
 		if (removed_entry->second->child) {
 			removed_entry->second->child->parent = nullptr;
-			mapping[to_be_removed_node->name] = std::move(removed_entry->second->child);
+			mapping[to_be_removed_node.name] = std::move(removed_entry->second->child);
 		} else {
 			mapping.erase(removed_entry);
 		}
 	}
-	if (to_be_removed_node->parent) {
+	if (to_be_removed_node.parent) {
 		// if the to be removed node has a parent, set the child pointer to the
 		// to be restored node
-		to_be_removed_node->parent->child = std::move(to_be_removed_node->child);
-		entry.parent = to_be_removed_node->parent;
+		to_be_removed_node.parent->child = std::move(to_be_removed_node.child);
+		entry.parent = to_be_removed_node.parent;
 	} else {
 		// otherwise we need to update the base entry tables
 		auto &name = entry.name;
-		to_be_removed_node->child->SetAsRoot();
-		mapping[name]->index.GetEntry() = std::move(to_be_removed_node->child);
+		to_be_removed_node.child->SetAsRoot();
+		mapping[name]->index.GetEntry() = std::move(to_be_removed_node.child);
 		entry.parent = nullptr;
 	}
 

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -186,15 +186,15 @@ static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_sch
 	return nullptr;
 }
 
-DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
+DefaultFunctionGenerator::DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
     : DefaultGenerator(catalog), schema(schema) {
 }
 
 unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientContext &context,
                                                                       const string &entry_name) {
-	auto info = GetDefaultFunction(schema->name, entry_name);
+	auto info = GetDefaultFunction(schema.name, entry_name);
 	if (info) {
-		return make_uniq_base<CatalogEntry, ScalarMacroCatalogEntry>(&catalog, schema, (CreateMacroInfo *)info.get());
+		return make_uniq_base<CatalogEntry, ScalarMacroCatalogEntry>(&catalog, &schema, (CreateMacroInfo *)info.get());
 	}
 	return nullptr;
 }
@@ -202,7 +202,7 @@ unique_ptr<CatalogEntry> DefaultFunctionGenerator::CreateDefaultEntry(ClientCont
 vector<string> DefaultFunctionGenerator::GetDefaultEntries() {
 	vector<string> result;
 	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
-		if (internal_macros[index].schema == schema->name) {
+		if (internal_macros[index].schema == schema.name) {
 			result.emplace_back(internal_macros[index].name);
 		}
 	}

package/src/duckdb/src/catalog/default/default_types.cpp

@@ -94,12 +94,12 @@ LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) {
 	return LogicalTypeId::INVALID;
 }
 
-DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
+DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
     : DefaultGenerator(catalog), schema(schema) {
 }
 
 unique_ptr<CatalogEntry> DefaultTypeGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	if (schema->name != DEFAULT_SCHEMA) {
+	if (schema.name != DEFAULT_SCHEMA) {
 		return nullptr;
 	}
 	auto type_id = GetDefaultType(entry_name);
@@ -111,12 +111,12 @@ unique_ptr<CatalogEntry> DefaultTypeGenerator::CreateDefaultEntry(ClientContext
 	info.type = LogicalType(type_id);
 	info.internal = true;
 	info.temporary = true;
-	return make_uniq_base<CatalogEntry, TypeCatalogEntry>(&catalog, schema, &info);
+	return make_uniq_base<CatalogEntry, TypeCatalogEntry>(&catalog, &schema, &info);
 }
 
 vector<string> DefaultTypeGenerator::GetDefaultEntries() {
 	vector<string> result;
-	if (schema->name != DEFAULT_SCHEMA) {
+	if (schema.name != DEFAULT_SCHEMA) {
 		return result;
 	}
 	for (idx_t index = 0; internal_types[index].name != nullptr; index++) {

package/src/duckdb/src/catalog/default/default_views.cpp

@@ -69,14 +69,14 @@ static unique_ptr<CreateViewInfo> GetDefaultView(ClientContext &context, const s
 	return nullptr;
 }
 
-DefaultViewGenerator::DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry *schema)
+DefaultViewGenerator::DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
     : DefaultGenerator(catalog), schema(schema) {
 }
 
 unique_ptr<CatalogEntry> DefaultViewGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	auto info = GetDefaultView(context, schema->name, entry_name);
+	auto info = GetDefaultView(context, schema.name, entry_name);
 	if (info) {
-		return make_uniq_base<CatalogEntry, ViewCatalogEntry>(&catalog, schema, info.get());
+		return make_uniq_base<CatalogEntry, ViewCatalogEntry>(&catalog, &schema, info.get());
 	}
 	return nullptr;
 }
@@ -84,7 +84,7 @@ unique_ptr<CatalogEntry> DefaultViewGenerator::CreateDefaultEntry(ClientContext
 vector<string> DefaultViewGenerator::GetDefaultEntries() {
 	vector<string> result;
 	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
-		if (internal_views[index].schema == schema->name) {
+		if (internal_views[index].schema == schema.name) {
 			result.emplace_back(internal_views[index].name);
 		}
 	}

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

@@ -4,20 +4,21 @@
 
 namespace duckdb {
 
-void DependencyList::AddDependency(CatalogEntry *entry) {
-	if (entry->internal) {
+void DependencyList::AddDependency(CatalogEntry &entry) {
+	if (entry.internal) {
 		return;
 	}
 	set.insert(entry);
 }
 
-void DependencyList::VerifyDependencies(Catalog *catalog, const string &name) {
-	for (auto &dep : set) {
-		if (dep->catalog != catalog) {
+void DependencyList::VerifyDependencies(Catalog &catalog, const string &name) {
+	for (auto &dep_entry : set) {
+		auto &dep = dep_entry.get();
+		if (dep.catalog != &catalog) {
 			throw DependencyException(
 			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
 			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    name, dep->name, dep->catalog->GetName(), catalog->GetName());
+			    name, dep.name, dep.catalog->GetName(), catalog.GetName());
 		}
 	}
 }