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

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/execution/expression_executor_state.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
@@ -39,13 +40,13 @@ class DependencyList;
 class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
-	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
+	FunctionStatisticsInput(BoundFunctionExpression &expr_p, optional_ptr<FunctionData> bind_data_p,
 	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
 	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
 	}
 
 	BoundFunctionExpression &expr;
-	FunctionData *bind_data;
+	optional_ptr<FunctionData> bind_data;
 	vector<BaseStatistics> &child_stats;
 	unique_ptr<Expression> *expr_ptr;
 };

package/src/duckdb/src/include/duckdb/function/table/table_scan.hpp

@@ -17,11 +17,11 @@ class DuckTableEntry;
 class TableCatalogEntry;
 
 struct TableScanBindData : public TableFunctionData {
-	explicit TableScanBindData(DuckTableEntry *table) : table(table), is_index_scan(false), is_create_index(false) {
+	explicit TableScanBindData(DuckTableEntry &table) : table(table), is_index_scan(false), is_create_index(false) {
 	}
 
 	//! The table to scan
-	DuckTableEntry *table;
+	DuckTableEntry &table;
 
 	//! Whether or not the table scan is an index scan
 	bool is_index_scan;
@@ -33,7 +33,7 @@ struct TableScanBindData : public TableFunctionData {
 public:
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = (const TableScanBindData &)other_p;
-		return other.table == table && result_ids == other.result_ids;
+		return &other.table == &table && result_ids == other.result_ids;
 	}
 };
 
@@ -42,7 +42,8 @@ struct TableScanFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 	static TableFunction GetFunction();
 	static TableFunction GetIndexScanFunction();
-	static TableCatalogEntry *GetTableEntry(const TableFunction &function, const FunctionData *bind_data);
+	static optional_ptr<TableCatalogEntry> GetTableEntry(const TableFunction &function,
+	                                                     const optional_ptr<FunctionData> bind_data);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -26,6 +27,17 @@ class TableFilterSet;
 
 struct TableFunctionInfo {
 	DUCKDB_API virtual ~TableFunctionInfo();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 struct GlobalTableFunctionState {
@@ -70,7 +82,7 @@ struct LocalTableFunctionState {
 struct TableFunctionBindInput {
 	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
 	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       TableFunctionInfo *info)
+	                       optional_ptr<TableFunctionInfo> info)
 	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
 	      input_table_names(input_table_names), info(info) {
 	}
@@ -79,19 +91,19 @@ struct TableFunctionBindInput {
 	named_parameter_map_t &named_parameters;
 	vector<LogicalType> &input_table_types;
 	vector<string> &input_table_names;
-	TableFunctionInfo *info;
+	optional_ptr<TableFunctionInfo> info;
 };
 
 struct TableFunctionInitInput {
-	TableFunctionInitInput(const FunctionData *bind_data_p, const vector<column_t> &column_ids_p,
-	                       const vector<idx_t> &projection_ids_p, TableFilterSet *filters_p)
+	TableFunctionInitInput(optional_ptr<const FunctionData> bind_data_p, const vector<column_t> &column_ids_p,
+	                       const vector<idx_t> &projection_ids_p, optional_ptr<TableFilterSet> filters_p)
 	    : bind_data(bind_data_p), column_ids(column_ids_p), projection_ids(projection_ids_p), filters(filters_p) {
 	}
 
-	const FunctionData *bind_data;
+	optional_ptr<const FunctionData> bind_data;
 	const vector<column_t> &column_ids;
 	const vector<idx_t> projection_ids;
-	TableFilterSet *filters;
+	optional_ptr<TableFilterSet> filters;
 
 	bool CanRemoveFilterColumns() const {
 		if (projection_ids.empty()) {
@@ -109,15 +121,16 @@ struct TableFunctionInitInput {
 
 struct TableFunctionInput {
 public:
-	TableFunctionInput(const FunctionData *bind_data_p, LocalTableFunctionState *local_state_p,
-	                   GlobalTableFunctionState *global_state_p)
+	TableFunctionInput(optional_ptr<const FunctionData> bind_data_p,
+	                   optional_ptr<LocalTableFunctionState> local_state_p,
+	                   optional_ptr<GlobalTableFunctionState> global_state_p)
 	    : bind_data(bind_data_p), local_state(local_state_p), global_state(global_state_p) {
 	}
 
 public:
-	const FunctionData *bind_data;
-	LocalTableFunctionState *local_state;
-	GlobalTableFunctionState *global_state;
+	optional_ptr<const FunctionData> bind_data;
+	optional_ptr<LocalTableFunctionState> local_state;
+	optional_ptr<GlobalTableFunctionState> global_state;
 };
 
 enum ScanType { TABLE, PARQUET };
@@ -127,21 +140,21 @@ public:
 	explicit BindInfo(ScanType type_p) : type(type_p) {};
 	unordered_map<string, Value> options;
 	ScanType type;
-	void InsertOption(string name, Value value) {
+	void InsertOption(const string &name, Value value) {
 		if (options.find(name) != options.end()) {
 			throw InternalException("This option already exists");
 		}
-		options[name] = value;
+		options[name] = std::move(value);
 	}
 	template <class T>
-	T GetOption(string name) {
+	T GetOption(const string &name) {
 		if (options.find(name) == options.end()) {
 			throw InternalException("This option does not exist");
 		}
 		return options[name].GetValue<T>();
 	}
 	template <class T>
-	vector<T> GetOptionList(string name) {
+	vector<T> GetOptionList(const string &name) {
 		if (options.find(name) == options.end()) {
 			throw InternalException("This option does not exist");
 		}

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -44,6 +44,7 @@ public:
 
 	void Initialize();
 
+	Catalog &ParentCatalog() override;
 	StorageManager &GetStorageManager();
 	Catalog &GetCatalog();
 	TransactionManager &GetTransactionManager();
@@ -65,6 +66,7 @@ private:
 	unique_ptr<Catalog> catalog;
 	unique_ptr<TransactionManager> transaction_manager;
 	AttachedDatabaseType type;
+	optional_ptr<Catalog> parent_catalog;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -149,7 +149,7 @@ public:
 	DUCKDB_API double GetProgress();
 
 	//! Register function in the temporary schema
-	DUCKDB_API void RegisterFunction(CreateFunctionInfo *info);
+	DUCKDB_API void RegisterFunction(CreateFunctionInfo &info);
 
 	//! Parse statements from a query
 	DUCKDB_API vector<unique_ptr<SQLStatement>> ParseStatements(const string &query);

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -39,13 +40,13 @@ public:
 	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
 	//! Add a new attached database to the database manager
 	void AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db);
-	void DetachDatabase(ClientContext &context, const string &name, bool if_exists);
+	void DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found);
 	//! Returns a reference to the system catalog
 	Catalog &GetSystemCatalog();
 	static const string &GetDefaultDatabase(ClientContext &context);
 
 	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
-	vector<optional_ptr<AttachedDatabase>> GetDatabases(ClientContext &context);
+	vector<reference<AttachedDatabase>> GetDatabases(ClientContext &context);
 
 	transaction_t GetNewQueryNumber() {
 		return current_query_number++;

package/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp

@@ -28,6 +28,8 @@ public:
 	unique_ptr<Expression> expr;
 
 public:
+	static unique_ptr<Expression> &GetExpression(ParsedExpression &expr);
+
 	string ToString() const override;
 
 	bool Equals(const BaseExpression *other) const override;

package/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp

@@ -18,10 +18,10 @@ public:
 	static bool IsKeyword(const string &text);
 
 	//! Returns true if the given string needs to be quoted when written as an identifier
-	static bool RequiresQuotes(const string &text, bool allow_caps = false);
+	static bool RequiresQuotes(const string &text, bool allow_caps = true);
 
 	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
-	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = false);
+	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 
@@ -27,23 +28,24 @@ enum class AlterType : uint8_t {
 struct AlterEntryData {
 	AlterEntryData() {
 	}
-	AlterEntryData(string catalog_p, string schema_p, string name_p, bool if_exists)
-	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)), if_exists(if_exists) {
+	AlterEntryData(string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
+	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)),
+	      if_not_found(if_not_found) {
 	}
 
 	string catalog;
 	string schema;
 	string name;
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 };
 
 struct AlterInfo : public ParseInfo {
-	AlterInfo(AlterType type, string catalog, string schema, string name, bool if_exists);
+	AlterInfo(AlterType type, string catalog, string schema, string name, OnEntryNotFound if_not_found);
 	virtual ~AlterInfo() override;
 
 	AlterType type;
 	//! if exists
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 	//! Catalog name to alter
 	string catalog;
 	//! Schema name to alter

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -22,7 +22,7 @@ enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
 //===--------------------------------------------------------------------===//
 struct ChangeOwnershipInfo : public AlterInfo {
 	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
-	                    string owner_schema, string owner_name, bool if_exists);
+	                    string owner_schema, string owner_name, OnEntryNotFound if_not_found);
 
 	// Catalog type refers to the entry type, since this struct is usually built from an
 	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp

@@ -22,7 +22,7 @@ class SchemaCatalogEntry;
 struct CreateTableInfo : public CreateInfo {
 	DUCKDB_API CreateTableInfo();
 	DUCKDB_API CreateTableInfo(string catalog, string schema, string name);
-	DUCKDB_API CreateTableInfo(SchemaCatalogEntry *schema, string name);
+	DUCKDB_API CreateTableInfo(SchemaCatalogEntry &schema, string name);
 
 	//! Table name to insert to
 	string table;

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp

@@ -16,7 +16,7 @@ class SchemaCatalogEntry;
 
 struct CreateViewInfo : public CreateInfo {
 	CreateViewInfo();
-	CreateViewInfo(SchemaCatalogEntry *schema, string view_name);
+	CreateViewInfo(SchemaCatalogEntry &schema, string view_name);
 	CreateViewInfo(string catalog_p, string schema_p, string view_name);
 
 	//! Table name to insert to

package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 
@@ -19,13 +20,13 @@ struct DetachInfo : public ParseInfo {
 	//! The alias of the attached database
 	string name;
 	//! Whether to throw an exception if alias is not found
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 
 public:
 	unique_ptr<DetachInfo> Copy() const {
 		auto result = make_uniq<DetachInfo>();
 		result->name = name;
-		result->if_exists = if_exists;
+		result->if_not_found = if_not_found;
 		return result;
 	}
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
-	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
 	}
 
 	//! The catalog type to drop
@@ -27,7 +27,7 @@ struct DropInfo : public ParseInfo {
 	//! Element name to drop
 	string name;
 	//! Ignore if the entry does not exist instead of failing
-	bool if_exists = false;
+	OnEntryNotFound if_not_found = OnEntryNotFound::THROW_EXCEPTION;
 	//! Cascade drop (drop all dependents instead of throwing an error if there
 	//! are any)
 	bool cascade = false;
@@ -41,7 +41,7 @@ public:
 		result->catalog = catalog;
 		result->schema = schema;
 		result->name = name;
-		result->if_exists = if_exists;
+		result->if_not_found = if_not_found;
 		result->cascade = cascade;
 		result->allow_drop_internal = allow_drop_internal;
 		return result;
@@ -53,7 +53,7 @@ public:
 		writer.WriteString(catalog);
 		writer.WriteString(schema);
 		writer.WriteString(name);
-		writer.WriteField(if_exists);
+		writer.WriteField(if_not_found);
 		writer.WriteField(cascade);
 		writer.WriteField(allow_drop_internal);
 		writer.Finalize();
@@ -66,7 +66,7 @@ public:
 		drop_info->catalog = reader.ReadRequired<string>();
 		drop_info->schema = reader.ReadRequired<string>();
 		drop_info->name = reader.ReadRequired<string>();
-		drop_info->if_exists = reader.ReadRequired<bool>();
+		drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
 		drop_info->cascade = reader.ReadRequired<bool>();
 		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
 		reader.Finalize();

package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp

@@ -15,6 +15,19 @@ namespace duckdb {
 struct ParseInfo {
 	virtual ~ParseInfo() {
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref.hpp

@@ -18,6 +18,9 @@ class Serializer;
 
 //! Represents a generic expression that returns a table.
 class TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::INVALID;
+
 public:
 	explicit TableRef(TableReferenceType type) : type(type) {
 	}
@@ -57,7 +60,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
+		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
 		return (TARGET &)*this;
@@ -65,7 +68,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
+		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
 		return (const TARGET &)*this;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -320,6 +320,8 @@ private:
 	//! Returns true if an expression is only a star (i.e. "*", without any other decorators)
 	bool ExpressionIsEmptyStar(ParsedExpression &expr);
 
+	OnEntryNotFound TransformOnEntryNotFound(bool missing_ok);
+
 private:
 	//! Current stack depth
 	idx_t stack_depth;

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -172,7 +172,7 @@ public:
 	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
 
 	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
-	static void BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog = nullptr,
+	static void BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog = nullptr,
 	                            const string &schema = INVALID_SCHEMA);
 
 	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
@@ -259,7 +259,7 @@ private:
 	                             const string &alias, idx_t update_table_index,
 	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
 
-	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);
+	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
 
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -43,8 +43,7 @@ protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
-	BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
-	                         idx_t depth) override;
+	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth) override;
 
 	bool inside_window;
 	bool bound_aggregate = false;

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -134,14 +134,11 @@ protected:
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
-	                                idx_t depth);
-	virtual BindResult BindLambdaFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
-	                                      idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
-	                                 idx_t depth);
+	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
+	virtual BindResult BindLambdaFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
+	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth);
 	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression);
-	virtual BindResult BindMacro(FunctionExpression &expr, optional_ptr<ScalarMacroCatalogEntry> macro, idx_t depth,
+	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry &macro, idx_t depth,
 	                             unique_ptr<ParsedExpression> &expr_ptr);
 
 	virtual string UnsupportedAggregateMessage();

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -53,7 +53,7 @@ public:
 	string GetName() const override;
 	string ParamsToString() const override;
 	//! Returns the underlying table that is being scanned, or nullptr if there is none
-	TableCatalogEntry *GetTable() const;
+	optional_ptr<TableCatalogEntry> GetTable() const;
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;

package/src/duckdb/src/include/duckdb/transaction/transaction.hpp

@@ -57,6 +57,18 @@ public:
 	virtual bool IsDuckTransaction() const {
 		return false;
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/main/attached_database.cpp

@@ -8,8 +8,8 @@
 namespace duckdb {
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, nullptr,
-                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY,
+                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG, 0),
       db(db), type(type) {
 	D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE);
 	if (type == AttachedDatabaseType::TEMP_DATABASE) {
@@ -22,9 +22,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType ty
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p,
                                    AccessMode access_mode)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, &catalog_p, std::move(name_p)), db(db),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db),
       type(access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
-                                                : AttachedDatabaseType::READ_WRITE_DATABASE) {
+                                                : AttachedDatabaseType::READ_WRITE_DATABASE),
+      parent_catalog(&catalog_p) {
 	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY);
 	catalog = make_uniq<DuckCatalog>(*this);
 	transaction_manager = make_uniq<DuckTransactionManager>(*this);
@@ -33,9 +34,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, StorageExtension &storage_extension,
                                    string name_p, AttachInfo &info, AccessMode access_mode)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, &catalog_p, std::move(name_p)), db(db),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db),
       type(access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
-                                                : AttachedDatabaseType::READ_WRITE_DATABASE) {
+                                                : AttachedDatabaseType::READ_WRITE_DATABASE),
+      parent_catalog(&catalog_p) {
 	catalog = storage_extension.attach(storage_extension.storage_info.get(), *this, name, info, access_mode);
 	if (!catalog) {
 		throw InternalException("AttachedDatabase - attach function did not return a catalog");
@@ -116,4 +118,8 @@ TransactionManager &AttachedDatabase::GetTransactionManager() {
 	return *transaction_manager;
 }
 
+Catalog &AttachedDatabase::ParentCatalog() {
+	return *parent_catalog;
+}
+
 } // namespace duckdb