duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -15,7 +15,7 @@
 #include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
-
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 #include <functional>
 
 namespace duckdb {
@@ -110,100 +110,121 @@ public:
 	DUCKDB_API CatalogTransaction GetCatalogTransaction(ClientContext &context);
 
 	//! Creates a schema in the catalog.
-	DUCKDB_API virtual CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) = 0;
-	DUCKDB_API CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
+	DUCKDB_API virtual optional_ptr<CatalogEntry> CreateSchema(CatalogTransaction transaction,
+	                                                           CreateSchemaInfo &info) = 0;
+	DUCKDB_API optional_ptr<CatalogEntry> CreateSchema(ClientContext &context, CreateSchemaInfo &info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info);
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(ClientContext &context, BoundCreateTableInfo &info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
 	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info);
-	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
+	                                                          CreateTableFunctionInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(ClientContext &context, CreateTableFunctionInfo &info);
+	// Kept for backwards compatibility
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTableFunction(ClientContext &context,
+	                                                          optional_ptr<CreateTableFunctionInfo> info);
 	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info);
-	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
+	                                                         CreateCopyFunctionInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo &info);
 	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info);
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
+	                                                           CreatePragmaFunctionInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo &info);
 	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info);
-	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(ClientContext &context, CreateFunctionInfo &info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info);
-	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateView(ClientContext &context, CreateViewInfo &info);
 	//! Creates a sequence in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info);
-	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(ClientContext &context, CreateSequenceInfo &info);
 	//! Creates a Enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info);
-	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateType(ClientContext &context, CreateTypeInfo &info);
 	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info);
-	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(ClientContext &context, CreateCollationInfo &info);
 	//! Creates an index in the catalog
-	DUCKDB_API CatalogEntry *CreateIndex(CatalogTransaction transaction, CreateIndexInfo *info);
-	DUCKDB_API CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info);
 
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                     BoundCreateTableInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                  BoundCreateTableInfo &info);
 	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                             CreateTableFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry>
+	CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTableFunctionInfo &info);
 	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                            CreateCopyFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                         CreateCopyFunctionInfo &info);
 	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                              CreatePragmaFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry>
+	CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreatePragmaFunctionInfo &info);
 	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                        CreateFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                     CreateFunctionInfo &info);
 	//! Creates a view in the catalog
-	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                    CreateViewInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                 CreateViewInfo &info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                        CreateSequenceInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                     CreateSequenceInfo &info);
 	//! Creates a enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                    CreateTypeInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                 CreateTypeInfo &info);
 	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
-	                                         CreateCollationInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
+	                                                      CreateCollationInfo &info);
 
 	//! Drops an entry from the catalog
-	DUCKDB_API void DropEntry(ClientContext &context, DropInfo *info);
+	DUCKDB_API void DropEntry(ClientContext &context, DropInfo &info);
 
 	//! Returns the schema object with the specified name, or throws an exception if it does not exist
-	DUCKDB_API SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
-	                                         bool if_exists = false,
+	DUCKDB_API SchemaCatalogEntry &GetSchema(ClientContext &context, const string &name,
+	                                         QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API optional_ptr<SchemaCatalogEntry> GetSchema(ClientContext &context, const string &name,
+	                                                      OnEntryNotFound if_not_found,
+	                                                      QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API SchemaCatalogEntry &GetSchema(CatalogTransaction transaction, const string &name,
 	                                         QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API virtual SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
-	                                                 bool if_exists = false,
-	                                                 QueryErrorContext error_context = QueryErrorContext()) = 0;
-	DUCKDB_API static SchemaCatalogEntry *GetSchema(ClientContext &context, const string &catalog_name,
-	                                                const string &schema_name, bool if_exists = false,
+	DUCKDB_API virtual optional_ptr<SchemaCatalogEntry>
+	GetSchema(CatalogTransaction transaction, const string &schema_name, OnEntryNotFound if_not_found,
+	          QueryErrorContext error_context = QueryErrorContext()) = 0;
+	DUCKDB_API static SchemaCatalogEntry &GetSchema(ClientContext &context, const string &catalog_name,
+	                                                const string &schema_name,
 	                                                QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API static optional_ptr<SchemaCatalogEntry> GetSchema(ClientContext &context, const string &catalog_name,
+	                                                             const string &schema_name,
+	                                                             OnEntryNotFound if_not_found,
+	                                                             QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
-	DUCKDB_API virtual void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) = 0;
-	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not
-	//! exist, otherwise an exception is thrown
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema,
-	                                  const string &name, bool if_exists = false,
-	                                  QueryErrorContext error_context = QueryErrorContext());
-	//! Gets the "catalog.schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not
-	//! exist, otherwise an exception is thrown
-	DUCKDB_API static CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &catalog,
-	                                         const string &schema, const string &name, bool if_exists = false,
+	DUCKDB_API virtual void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) = 0;
+	//! Gets the "schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound
+	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(ClientContext &context, CatalogType type, const string &schema,
+	                                               const string &name, OnEntryNotFound if_not_found,
+	                                               QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API CatalogEntry &GetEntry(ClientContext &context, CatalogType type, const string &schema,
+	                                  const string &name, QueryErrorContext error_context = QueryErrorContext());
+	//! Gets the "catalog.schema.name" entry of the specified type, if entry does not exist behavior depends on
+	//! OnEntryNotFound
+	DUCKDB_API static optional_ptr<CatalogEntry> GetEntry(ClientContext &context, CatalogType type,
+	                                                      const string &catalog, const string &schema,
+	                                                      const string &name, OnEntryNotFound if_not_found,
+	                                                      QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API static CatalogEntry &GetEntry(ClientContext &context, CatalogType type, const string &catalog,
+	                                         const string &schema, const string &name,
 	                                         QueryErrorContext error_context = QueryErrorContext());
 
 	//! Gets the "schema.name" entry without a specified type, if entry does not exist an exception is thrown
-	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &schema, const string &name);
+	DUCKDB_API CatalogEntry &GetEntry(ClientContext &context, const string &schema, const string &name);
 
 	//! Fetches a logical type from the catalog
-	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &names, bool if_exists);
+	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &names,
+	                               OnEntryNotFound if_not_found);
 
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
@@ -212,20 +233,29 @@ public:
 	                       const string &name);
 
 	template <class T>
-	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
-	            QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry = GetEntry(context, T::Type, schema_name, name, if_exists, error_context);
-		if (entry && entry->type != T::Type) {
+	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
+	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry = GetEntry(context, T::Type, schema_name, name, if_not_found, error_context);
+		if (!entry) {
+			return nullptr;
+		}
+		if (entry->type != T::Type) {
 			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
 		}
-		return (T *)entry;
+		return &entry->template Cast<T>();
+	}
+	template <class T>
+	T &GetEntry(ClientContext &context, const string &schema_name, const string &name,
+	            QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry = GetEntry<T>(context, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+		return *entry;
 	}
 
 	//! Append a scalar or aggregate function to the catalog
-	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
+	DUCKDB_API optional_ptr<CatalogEntry> AddFunction(ClientContext &context, CreateFunctionInfo &info);
 
 	//! Alter an existing entry in the catalog.
-	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
+	DUCKDB_API void Alter(ClientContext &context, AlterInfo &info);
 
 	virtual unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
 	                                                       unique_ptr<PhysicalOperator> plan) = 0;
@@ -245,19 +275,30 @@ public:
 
 public:
 	template <class T>
-	static T *GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
-	                   const string &name, bool if_exists = false,
-	                   QueryErrorContext error_context = QueryErrorContext()) {
-		auto entry = GetEntry(context, T::Type, catalog_name, schema_name, name, if_exists, error_context);
-		if (entry && entry->type != T::Type) {
+	static optional_ptr<T> GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
+	                                const string &name, OnEntryNotFound if_not_found,
+	                                QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry = GetEntry(context, T::Type, catalog_name, schema_name, name, if_not_found, error_context);
+		if (!entry) {
+			return nullptr;
+		}
+		if (entry->type != T::Type) {
 			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
 		}
-		return (T *)entry;
+		return &entry->template Cast<T>();
+	}
+	template <class T>
+	static T &GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
+	                   const string &name, QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry =
+		    GetEntry<T>(context, catalog_name, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+		return *entry;
 	}
 
-	DUCKDB_API vector<SchemaCatalogEntry *> GetSchemas(ClientContext &context);
-	DUCKDB_API static vector<SchemaCatalogEntry *> GetSchemas(ClientContext &context, const string &catalog_name);
-	DUCKDB_API static vector<SchemaCatalogEntry *> GetAllSchemas(ClientContext &context);
+	DUCKDB_API vector<reference<SchemaCatalogEntry>> GetSchemas(ClientContext &context);
+	DUCKDB_API static vector<reference<SchemaCatalogEntry>> GetSchemas(ClientContext &context,
+	                                                                   const string &catalog_name);
+	DUCKDB_API static vector<reference<SchemaCatalogEntry>> GetAllSchemas(ClientContext &context);
 
 	virtual void Verify();
 
@@ -271,9 +312,9 @@ private:
 	CatalogEntryLookup LookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
 	                                       const string &name);
 	CatalogEntryLookup LookupEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
-	                               bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
+	                               OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext());
 	static CatalogEntryLookup LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
-	                                      const string &name, bool if_exists = false,
+	                                      const string &name, OnEntryNotFound if_not_found,
 	                                      QueryErrorContext error_context = QueryErrorContext());
 
 	//! Return an exception with did-you-mean suggestion.
@@ -286,7 +327,7 @@ private:
 	static SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
 	                                                 const reference_set_t<SchemaCatalogEntry> &schemas);
 
-	virtual void DropSchema(ClientContext &context, DropInfo *info) = 0;
+	virtual void DropSchema(ClientContext &context, DropInfo &info) = 0;
 
 public:
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp

@@ -22,9 +22,8 @@ public:
 	static constexpr const char *Name = "aggregate function";
 
 public:
-	AggregateFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateAggregateFunctionInfo *info)
-	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info->name),
-	      functions(info->functions) {
+	AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info)
+	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info.name), functions(info.functions) {
 	}
 
 	//! The aggregate functions

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/collate_catalog_entry.hpp

@@ -21,9 +21,9 @@ public:
 	static constexpr const char *Name = "collation";
 
 public:
-	CollateCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCollationInfo *info)
-	    : StandardEntry(CatalogType::COLLATION_ENTRY, schema, catalog, info->name), function(info->function),
-	      combinable(info->combinable), not_required_for_equality(info->not_required_for_equality) {
+	CollateCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateCollationInfo &info)
+	    : StandardEntry(CatalogType::COLLATION_ENTRY, schema, catalog, info.name), function(info.function),
+	      combinable(info.combinable), not_required_for_equality(info.not_required_for_equality) {
 	}
 
 	//! The collation function to push in case collation is required

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp

@@ -24,7 +24,7 @@ public:
 	static constexpr const char *Name = "copy function";
 
 public:
-	CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCopyFunctionInfo *info);
+	CopyFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateCopyFunctionInfo &info);
 
 	//! The copy function
 	CopyFunction function;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 class DuckIndexEntry : public IndexCatalogEntry {
 public:
 	//! Create an IndexCatalogEntry and initialize storage for it
-	DuckIndexEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);
+	DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
 	~DuckIndexEntry();
 
 	shared_ptr<DataTableInfo> info;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_schema_entry.hpp

@@ -15,7 +15,7 @@ namespace duckdb {
 //! A schema in the catalog
 class DuckSchemaEntry : public SchemaCatalogEntry {
 public:
-	DuckSchemaEntry(Catalog *catalog, string name, bool is_internal);
+	DuckSchemaEntry(Catalog &catalog, string name, bool is_internal);
 
 private:
 	//! The catalog set holding the tables
@@ -38,26 +38,30 @@ private:
 	CatalogSet types;
 
 public:
-	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                       OnCreateConflict on_conflict);
-	CatalogEntry *AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                               OnCreateConflict on_conflict, DependencyList dependencies);
+	optional_ptr<CatalogEntry> AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                                    OnCreateConflict on_conflict);
+	optional_ptr<CatalogEntry> AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                                            OnCreateConflict on_conflict, DependencyList dependencies);
 
-	CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) override;
-	CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) override;
-	CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) override;
-	CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info) override;
-	CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) override;
-	CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) override;
-	CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) override;
-	CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) override;
-	CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) override;
-	CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info) override;
-	void Alter(ClientContext &context, AlterInfo *info) override;
-	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry *)> &callback) override;
-	void Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) override;
-	void DropEntry(ClientContext &context, DropInfo *info) override;
-	CatalogEntry *GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
+	optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) override;
+	optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) override;
+	optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info,
+	                                       TableCatalogEntry &table) override;
+	optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info) override;
+	optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) override;
+	optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
+	                                               CreateTableFunctionInfo &info) override;
+	optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
+	                                              CreateCopyFunctionInfo &info) override;
+	optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
+	                                                CreatePragmaFunctionInfo &info) override;
+	optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) override;
+	optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info) override;
+	void Alter(ClientContext &context, AlterInfo &info) override;
+	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
+	void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
+	void DropEntry(ClientContext &context, DropInfo &info) override;
+	optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
 	SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
 
 	void Verify(Catalog &catalog) override;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -16,12 +16,12 @@ namespace duckdb {
 class DuckTableEntry : public TableCatalogEntry {
 public:
 	//! Create a TableCatalogEntry and initialize storage for it
-	DuckTableEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
+	DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
 	               std::shared_ptr<DataTable> inherited_storage = nullptr);
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
-	void UndoAlter(ClientContext &context, AlterInfo *info) override;
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
+	void UndoAlter(ClientContext &context, AlterInfo &info) override;
 	//! Returns the underlying storage of the table
 	DataTable &GetStorage() override;
 	//! Returns a list of the bound constraints of the table

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -25,7 +25,7 @@ public:
 
 public:
 	//! Create an IndexCatalogEntry and initialize storage for it
-	IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);
+	IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
 
 	optional_ptr<Index> index;
 	string sql;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 //! A macro function in the catalog
 class MacroCatalogEntry : public StandardEntry {
 public:
-	MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
+	MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
 
 	//! The macro function
 	unique_ptr<MacroFunction> function;
@@ -28,7 +28,7 @@ public:
 	virtual void Serialize(Serializer &serializer) const = 0;
 
 	string ToSQL() const override {
-		return function->ToSQL(schema->name, name);
+		return function->ToSQL(schema.name, name);
 	}
 };
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp

@@ -24,7 +24,7 @@ public:
 	static constexpr const char *Name = "pragma function";
 
 public:
-	PragmaFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreatePragmaFunctionInfo *info);
+	PragmaFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreatePragmaFunctionInfo &info);
 
 	//! The pragma functions
 	PragmaFunctionSet functions;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp

@@ -22,12 +22,12 @@ public:
 	static constexpr const char *Name = "scalar function";
 
 public:
-	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info);
+	ScalarFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateScalarFunctionInfo &info);
 
 	//! The scalar functions
 	ScalarFunctionSet functions;
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp

@@ -22,7 +22,7 @@ public:
 	static constexpr const char *Name = "macro function";
 
 public:
-	ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
+	ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
 
 public:
 	//! Serialize the meta information of the ScalarMacroCatalogEntry

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp

@@ -40,20 +40,20 @@ struct CreateTypeInfo;
 struct DropInfo;
 
 //! A schema in the catalog
-class SchemaCatalogEntry : public CatalogEntry {
+class SchemaCatalogEntry : public InCatalogEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::SCHEMA_ENTRY;
 	static constexpr const char *Name = "schema";
 
 public:
-	SchemaCatalogEntry(Catalog *catalog, string name, bool is_internal);
+	SchemaCatalogEntry(Catalog &catalog, string name, bool is_internal);
 
 public:
 	//! Scan the specified catalog set, invoking the callback method for every entry
 	virtual void Scan(ClientContext &context, CatalogType type,
-	                  const std::function<void(CatalogEntry *)> &callback) = 0;
+	                  const std::function<void(CatalogEntry &)> &callback) = 0;
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
-	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) = 0;
+	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) = 0;
 
 	//! Serialize the meta information of the SchemaCatalogEntry a serializer
 	virtual void Serialize(Serializer &serializer) const;
@@ -63,35 +63,40 @@ public:
 	string ToSQL() const override;
 
 	//! Creates an index with the given name in the schema
-	virtual CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) = 0;
+	virtual optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info,
+	                                               TableCatalogEntry &table) = 0;
 	//! Create a scalar or aggregate function within the given schema
-	virtual CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) = 0;
 	//! Creates a table with the given name in the schema
-	virtual CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) = 0;
 	//! Creates a view with the given name in the schema
-	virtual CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info) = 0;
 	//! Creates a sequence with the given name in the schema
-	virtual CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) = 0;
 	//! Create a table function within the given schema
-	virtual CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateTableFunction(CatalogTransaction transaction,
+	                                                       CreateTableFunctionInfo &info) = 0;
 	//! Create a copy function within the given schema
-	virtual CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateCopyFunction(CatalogTransaction transaction,
+	                                                      CreateCopyFunctionInfo &info) = 0;
 	//! Create a pragma function within the given schema
-	virtual CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreatePragmaFunction(CatalogTransaction transaction,
+	                                                        CreatePragmaFunctionInfo &info) = 0;
 	//! Create a collation within the given schema
-	virtual CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) = 0;
 	//! Create a enum within the given schema
-	virtual CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info) = 0;
+	virtual optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info) = 0;
 
-	DUCKDB_API virtual CatalogEntry *GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) = 0;
+	DUCKDB_API virtual optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type,
+	                                                       const string &name) = 0;
 	DUCKDB_API virtual SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
 	                                                       const string &name);
 
 	//! Drops an entry from the schema
-	virtual void DropEntry(ClientContext &context, DropInfo *info) = 0;
+	virtual void DropEntry(ClientContext &context, DropInfo &info) = 0;
 
 	//! Alters a catalog entry
-	virtual void Alter(ClientContext &context, AlterInfo *info) = 0;
+	virtual void Alter(ClientContext &context, AlterInfo &info) = 0;
 
 	CatalogTransaction GetCatalogTransaction(ClientContext &context);
 };

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp

@@ -35,7 +35,7 @@ public:
 
 public:
 	//! Create a real TableCatalogEntry and initialize storage for it
-	SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateSequenceInfo *info);
+	SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info);
 
 	//! Lock for getting a value on the sequence
 	mutex lock;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -48,7 +48,7 @@ public:
 
 public:
 	//! Create a TableCatalogEntry and initialize storage for it
-	DUCKDB_API TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableInfo &info);
+	DUCKDB_API TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info);
 
 public:
 	DUCKDB_API bool HasGeneratedColumns() const;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -22,12 +22,12 @@ public:
 	static constexpr const char *Name = "table function";
 
 public:
-	TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableFunctionInfo *info);
+	TableFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableFunctionInfo &info);
 
 	//! The table function
 	TableFunctionSet functions;
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp

@@ -21,7 +21,7 @@ public:
 	static constexpr const char *Name = "table macro function";
 
 public:
-	TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
+	TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
 
 public:
 	//! Serialize the meta information of the ScalarMacroCatalogEntry