duckdb 0.7.2-dev2430.0 → 0.7.2-dev2552.0

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

@@ -90,7 +90,7 @@ Catalog &Catalog::GetCatalog(ClientContext &context, const string &catalog_name)
 //===--------------------------------------------------------------------===//
 // Schema
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateSchema(ClientContext &context, CreateSchemaInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateSchema(ClientContext &context, CreateSchemaInfo &info) {
 	return CreateSchema(GetCatalogTransaction(context), info);
 }
 
@@ -101,177 +101,185 @@ CatalogTransaction Catalog::GetCatalogTransaction(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Table
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateTable(ClientContext &context, BoundCreateTableInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateTable(ClientContext &context, BoundCreateTableInfo &info) {
 	return CreateTable(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info) {
+optional_ptr<CatalogEntry> Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info) {
 	auto binder = Binder::CreateBinder(context);
 	auto bound_info = binder->BindCreateTableInfo(std::move(info));
-	return CreateTable(context, bound_info.get());
+	return CreateTable(context, *bound_info);
 }
 
-CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                   BoundCreateTableInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                BoundCreateTableInfo &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);
+optional_ptr<CatalogEntry> Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) {
+	auto &schema = GetSchema(transaction, info.base->schema);
+	return CreateTable(transaction, schema, info);
 }
 
 //===--------------------------------------------------------------------===//
 // View
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateView(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateView(CatalogTransaction transaction, CreateViewInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateView(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateView(ClientContext &context, CreateViewInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateView(ClientContext &context, CreateViewInfo &info) {
 	return CreateView(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateViewInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                               CreateViewInfo &info) {
 	return schema.CreateView(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Sequence
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateSequence(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateSequence(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo &info) {
 	return CreateSequence(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                      CreateSequenceInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                   CreateSequenceInfo &info) {
 	return schema.CreateSequence(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Type
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateType(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateType(CatalogTransaction transaction, CreateTypeInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateType(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateType(ClientContext &context, CreateTypeInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateType(ClientContext &context, CreateTypeInfo &info) {
 	return CreateType(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTypeInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                               CreateTypeInfo &info) {
 	return schema.CreateType(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Table Function
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateTableFunction(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateTableFunction(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo &info) {
 	return CreateTableFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                           CreateTableFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                        CreateTableFunctionInfo &info) {
 	return schema.CreateTableFunction(transaction, info);
 }
 
+optional_ptr<CatalogEntry> Catalog::CreateTableFunction(ClientContext &context,
+                                                        optional_ptr<CreateTableFunctionInfo> info) {
+	return CreateTableFunction(context, *info);
+}
+
 //===--------------------------------------------------------------------===//
 // Copy Function
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateCopyFunction(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateCopyFunction(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo &info) {
 	return CreateCopyFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                          CreateCopyFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                       CreateCopyFunctionInfo &info) {
 	return schema.CreateCopyFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Pragma Function
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreatePragmaFunction(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(CatalogTransaction transaction,
+                                                         CreatePragmaFunctionInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreatePragmaFunction(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo &info) {
 	return CreatePragmaFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                            CreatePragmaFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                         CreatePragmaFunctionInfo &info) {
 	return schema.CreatePragmaFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Function
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateFunction(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateFunction(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo &info) {
 	return CreateFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                      CreateFunctionInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                   CreateFunctionInfo &info) {
 	return schema.CreateFunction(transaction, info);
 }
 
-CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
-	info->on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
+optional_ptr<CatalogEntry> Catalog::AddFunction(ClientContext &context, CreateFunctionInfo &info) {
+	info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
 	return CreateFunction(context, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Collation
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
-	auto schema = GetSchema(transaction, info->schema);
-	return CreateCollation(transaction, *schema, info);
+optional_ptr<CatalogEntry> Catalog::CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) {
+	auto &schema = GetSchema(transaction, info.schema);
+	return CreateCollation(transaction, schema, info);
 }
 
-CatalogEntry *Catalog::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateCollation(ClientContext &context, CreateCollationInfo &info) {
 	return CreateCollation(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-                                       CreateCollationInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+                                                    CreateCollationInfo &info) {
 	return schema.CreateCollation(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Index
 //===--------------------------------------------------------------------===//
-CatalogEntry *Catalog::CreateIndex(CatalogTransaction transaction, CreateIndexInfo *info) {
+optional_ptr<CatalogEntry> Catalog::CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info) {
 	auto &context = transaction.GetContext();
 	return CreateIndex(context, info);
 }
 
-CatalogEntry *Catalog::CreateIndex(ClientContext &context, CreateIndexInfo *info) {
-	auto schema = GetSchema(context, info->schema);
-	auto table = GetEntry<TableCatalogEntry>(context, schema->name, info->table->table_name);
-	return schema->CreateIndex(context, info, table);
+optional_ptr<CatalogEntry> Catalog::CreateIndex(ClientContext &context, CreateIndexInfo &info) {
+	auto &schema = GetSchema(context, info.schema);
+	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table->table_name);
+	return schema.CreateIndex(context, info, table);
 }
 
 //===--------------------------------------------------------------------===//
@@ -298,15 +306,15 @@ struct CatalogEntryLookup {
 //===--------------------------------------------------------------------===//
 // Generic
 //===--------------------------------------------------------------------===//
-void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
+void Catalog::DropEntry(ClientContext &context, DropInfo &info) {
 	ModifyCatalog();
-	if (info->type == CatalogType::SCHEMA_ENTRY) {
+	if (info.type == CatalogType::SCHEMA_ENTRY) {
 		// DROP SCHEMA
 		DropSchema(context, info);
 		return;
 	}
 
-	auto lookup = LookupEntry(context, info->type, info->schema, info->name, info->if_exists);
+	auto lookup = LookupEntry(context, info.type, info.schema, info.name, info.if_not_found);
 	if (!lookup.Found()) {
 		return;
 	}
@@ -314,9 +322,23 @@ void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
 	lookup.schema->DropEntry(context, info);
 }
 
-SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
+SchemaCatalogEntry &Catalog::GetSchema(ClientContext &context, const string &name, QueryErrorContext error_context) {
+	return *Catalog::GetSchema(context, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+}
+
+optional_ptr<SchemaCatalogEntry> Catalog::GetSchema(ClientContext &context, const string &schema_name,
+                                                    OnEntryNotFound if_not_found, QueryErrorContext error_context) {
+	return GetSchema(GetCatalogTransaction(context), schema_name, if_not_found, error_context);
+}
+
+SchemaCatalogEntry &Catalog::GetSchema(ClientContext &context, const string &catalog_name, const string &schema_name,
                                        QueryErrorContext error_context) {
-	return GetSchema(GetCatalogTransaction(context), schema_name, if_exists, error_context);
+	return *Catalog::GetSchema(context, catalog_name, schema_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+}
+
+SchemaCatalogEntry &Catalog::GetSchema(CatalogTransaction transaction, const string &name,
+                                       QueryErrorContext error_context) {
+	return *GetSchema(transaction, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 }
 
 //===--------------------------------------------------------------------===//
@@ -327,7 +349,7 @@ SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const
 	SimilarCatalogEntry result;
 	for (auto schema_ref : schemas) {
 		auto &schema = schema_ref.get();
-		auto transaction = schema.catalog->GetCatalogTransaction(context);
+		auto transaction = schema.catalog.GetCatalogTransaction(context);
 		auto entry = schema.GetSimilarEntry(transaction, type, entry_name);
 		if (!entry.Found()) {
 			// no similar entry found
@@ -455,10 +477,10 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context);
 	for (auto database : databases) {
-		auto &catalog = database->GetCatalog();
+		auto &catalog = database.get().GetCatalog();
 		auto current_schemas = catalog.GetAllSchemas(context);
 		for (auto &current_schema : current_schemas) {
-			unseen_schemas.insert(*current_schema);
+			unseen_schemas.insert(current_schema.get());
 		}
 	}
 	// check if the entry exists in any extension
@@ -477,7 +499,7 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 	if (unseen_entry.Found() && unseen_entry.distance < entry.distance) {
 		// the closest matching entry requires qualification as it is not in the default search path
 		// check how to minimally qualify this entry
-		auto catalog_name = unseen_entry.schema->catalog->GetName();
+		auto catalog_name = unseen_entry.schema->catalog.GetName();
 		auto schema_name = unseen_entry.schema->name;
 		bool qualify_database;
 		bool qualify_schema;
@@ -493,8 +515,7 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 
 CatalogEntryLookup Catalog::LookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
                                                 const string &name) {
-
-	auto schema_entry = (SchemaCatalogEntry *)GetSchema(transaction, schema, true);
+	auto schema_entry = GetSchema(transaction, schema, OnEntryNotFound::RETURN_NULL);
 	if (!schema_entry) {
 		return {nullptr, nullptr};
 	}
@@ -506,7 +527,8 @@ CatalogEntryLookup Catalog::LookupEntryInternal(CatalogTransaction transaction,
 }
 
 CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema,
-                                        const string &name, bool if_exists, QueryErrorContext error_context) {
+                                        const string &name, OnEntryNotFound if_not_found,
+                                        QueryErrorContext error_context) {
 	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
@@ -536,14 +558,15 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 			schemas.insert(*result.schema);
 		}
 	}
-	if (if_exists) {
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
 		return {nullptr, nullptr};
 	}
 	throw CreateMissingEntryException(context, name, type, schemas, error_context);
 }
 
 CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
-                                        const string &name, bool if_exists, QueryErrorContext error_context) {
+                                        const string &name, OnEntryNotFound if_not_found,
+                                        QueryErrorContext error_context) {
 	reference_set_t<SchemaCatalogEntry> schemas;
 	for (auto &lookup : lookups) {
 		auto transaction = lookup.catalog.GetCatalogTransaction(context);
@@ -555,37 +578,44 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLo
 			schemas.insert(*result.schema);
 		}
 	}
-	if (if_exists) {
+	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
 		return {nullptr, nullptr};
 	}
 	throw CreateMissingEntryException(context, name, type, schemas, error_context);
 }
 
-CatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema, const string &name) {
+CatalogEntry &Catalog::GetEntry(ClientContext &context, const string &schema, const string &name) {
 	vector<CatalogType> entry_types {CatalogType::TABLE_ENTRY, CatalogType::SEQUENCE_ENTRY};
 
 	for (auto entry_type : entry_types) {
-		CatalogEntry *result = GetEntry(context, entry_type, schema, name, true);
-		if (result != nullptr) {
-			return result;
+		auto result = GetEntry(context, entry_type, schema, name, OnEntryNotFound::RETURN_NULL);
+		if (result) {
+			return *result;
 		}
 	}
 
 	throw CatalogException("CatalogElement \"%s.%s\" does not exist!", schema, name);
 }
 
-CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name, const string &name,
-                                bool if_exists, QueryErrorContext error_context) {
-	return LookupEntry(context, type, schema_name, name, if_exists, error_context).entry.get();
+optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name,
+                                             const string &name, OnEntryNotFound if_not_found,
+                                             QueryErrorContext error_context) {
+	return LookupEntry(context, type, schema_name, name, if_not_found, error_context).entry.get();
+}
+
+CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
+                                QueryErrorContext error_context) {
+	return *Catalog::GetEntry(context, type, schema, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 }
 
-CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog, const string &schema,
-                                const string &name, bool if_exists_p, QueryErrorContext error_context) {
+optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog,
+                                             const string &schema, const string &name, OnEntryNotFound if_not_found,
+                                             QueryErrorContext error_context) {
 	auto entries = GetCatalogEntries(context, catalog, schema);
 	vector<CatalogLookup> lookups;
 	lookups.reserve(entries.size());
 	for (auto &entry : entries) {
-		if (if_exists_p) {
+		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
 			auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
 			if (!catalog_entry) {
 				return nullptr;
@@ -595,59 +625,65 @@ CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const
 			lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
 		}
 	}
-	auto result = LookupEntry(context, lookups, type, name, if_exists_p, error_context);
+	auto result = LookupEntry(context, lookups, type, name, if_not_found, error_context);
 	if (!result.Found()) {
-		D_ASSERT(if_exists_p);
+		D_ASSERT(if_not_found == OnEntryNotFound::RETURN_NULL);
 		return nullptr;
 	}
 	return result.entry.get();
 }
 
-SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &catalog_name, const string &schema_name,
-                                       bool if_exists_p, QueryErrorContext error_context) {
+CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog, const string &schema,
+                                const string &name, QueryErrorContext error_context) {
+	return *Catalog::GetEntry(context, type, catalog, schema, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+}
+
+optional_ptr<SchemaCatalogEntry> Catalog::GetSchema(ClientContext &context, const string &catalog_name,
+                                                    const string &schema_name, OnEntryNotFound if_not_found,
+                                                    QueryErrorContext error_context) {
 	auto entries = GetCatalogEntries(context, catalog_name, schema_name);
-	SchemaCatalogEntry *result = nullptr;
 	for (idx_t i = 0; i < entries.size(); i++) {
-		auto if_exists = i + 1 == entries.size() ? if_exists_p : true;
+		auto on_not_found = i + 1 == entries.size() ? if_not_found : OnEntryNotFound::RETURN_NULL;
 		auto &catalog = Catalog::GetCatalog(context, entries[i].catalog);
-		auto result = catalog.GetSchema(context, schema_name, if_exists, error_context);
+		auto result = catalog.GetSchema(context, schema_name, on_not_found, error_context);
 		if (result) {
 			return result;
 		}
 	}
-	return result;
+	return nullptr;
 }
 
-LogicalType Catalog::GetType(ClientContext &context, const string &schema, const string &name, bool if_exists) {
-	auto type_entry = GetEntry<TypeCatalogEntry>(context, schema, name, if_exists);
+LogicalType Catalog::GetType(ClientContext &context, const string &schema, const string &name,
+                             OnEntryNotFound if_not_found) {
+	auto type_entry = GetEntry<TypeCatalogEntry>(context, schema, name, if_not_found);
 	if (!type_entry) {
 		return LogicalType::INVALID;
 	}
 	auto result_type = type_entry->user_type;
-	LogicalType::SetCatalog(result_type, type_entry);
+	EnumType::SetCatalog(result_type, type_entry.get());
 	return result_type;
 }
 
 LogicalType Catalog::GetType(ClientContext &context, const string &catalog_name, const string &schema,
                              const string &name) {
-	auto type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
-	auto result_type = type_entry->user_type;
-	LogicalType::SetCatalog(result_type, type_entry);
+	auto &type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
+	auto result_type = type_entry.user_type;
+	EnumType::SetCatalog(result_type, &type_entry);
 	return result_type;
 }
 
-vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context) {
-	vector<SchemaCatalogEntry *> schemas;
-	ScanSchemas(context, [&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
+vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context) {
+	vector<reference<SchemaCatalogEntry>> schemas;
+	ScanSchemas(context, [&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
 	return schemas;
 }
 
 bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, const string &schema, const string &name) {
-	CatalogEntry *entry;
-	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, true);
+	optional_ptr<CatalogEntry> entry;
+	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, OnEntryNotFound::RETURN_NULL);
 	if (!entry) {
 		// look in the system catalog
-		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, true);
+		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, OnEntryNotFound::RETURN_NULL);
 		if (!entry) {
 			return false;
 		}
@@ -655,8 +691,8 @@ bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, con
 	return true;
 }
 
-vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
-	vector<Catalog *> catalogs;
+vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
+	vector<reference<Catalog>> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {
 		unordered_set<string> name;
 
@@ -666,45 +702,48 @@ vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const s
 				continue;
 			}
 			name.insert(entry.catalog);
-			catalogs.push_back(&Catalog::GetCatalog(context, entry.catalog));
+			catalogs.push_back(Catalog::GetCatalog(context, entry.catalog));
 		}
 	} else {
-		catalogs.push_back(&Catalog::GetCatalog(context, catalog_name));
+		catalogs.push_back(Catalog::GetCatalog(context, catalog_name));
 	}
-	vector<SchemaCatalogEntry *> result;
+	vector<reference<SchemaCatalogEntry>> result;
 	for (auto catalog : catalogs) {
-		auto schemas = catalog->GetSchemas(context);
+		auto schemas = catalog.get().GetSchemas(context);
 		result.insert(result.end(), schemas.begin(), schemas.end());
 	}
 	return result;
 }
 
-vector<SchemaCatalogEntry *> Catalog::GetAllSchemas(ClientContext &context) {
-	vector<SchemaCatalogEntry *> result;
+vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &context) {
+	vector<reference<SchemaCatalogEntry>> result;
 
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context);
 	for (auto database : databases) {
-		auto &catalog = database->GetCatalog();
+		auto &catalog = database.get().GetCatalog();
 		auto new_schemas = catalog.GetSchemas(context);
 		result.insert(result.end(), new_schemas.begin(), new_schemas.end());
 	}
-	sort(result.begin(), result.end(), [&](SchemaCatalogEntry *x, SchemaCatalogEntry *y) {
-		if (x->catalog->GetName() < y->catalog->GetName()) {
-			return true;
-		}
-		if (x->catalog->GetName() == y->catalog->GetName()) {
-			return x->name < y->name;
-		}
-		return false;
-	});
+	sort(result.begin(), result.end(),
+	     [&](reference<SchemaCatalogEntry> left_p, reference<SchemaCatalogEntry> right_p) {
+		     auto &left = left_p.get();
+		     auto &right = right_p.get();
+		     if (left.catalog.GetName() < right.catalog.GetName()) {
+			     return true;
+		     }
+		     if (left.catalog.GetName() == right.catalog.GetName()) {
+			     return left.name < right.name;
+		     }
+		     return false;
+	     });
 
 	return result;
 }
 
-void Catalog::Alter(ClientContext &context, AlterInfo *info) {
+void Catalog::Alter(ClientContext &context, AlterInfo &info) {
 	ModifyCatalog();
-	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name, info->if_exists);
+	auto lookup = LookupEntry(context, info.GetCatalogType(), info.schema, info.name, info.if_not_found);
 	if (!lookup.Found()) {
 		return;
 	}

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

@@ -3,9 +3,9 @@
 
 namespace duckdb {
 
-CopyFunctionCatalogEntry::CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                   CreateCopyFunctionInfo *info)
-    : StandardEntry(CatalogType::COPY_FUNCTION_ENTRY, schema, catalog, info->name), function(info->function) {
+CopyFunctionCatalogEntry::CopyFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
+                                                   CreateCopyFunctionInfo &info)
+    : StandardEntry(CatalogType::COPY_FUNCTION_ENTRY, schema, catalog, info.name), function(info.function) {
 }
 
 } // namespace duckdb

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

@@ -4,7 +4,7 @@
 
 namespace duckdb {
 
-DuckIndexEntry::DuckIndexEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info)
+DuckIndexEntry::DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info)
     : IndexCatalogEntry(catalog, schema, info) {
 }