duckdb 0.7.2-dev1734.0 → 0.7.2-dev1867.0

package/src/duckdb/src/function/table/system/duckdb_columns.cpp

@@ -16,7 +16,7 @@ struct DuckDBColumnsData : public GlobalTableFunctionState {
 	DuckDBColumnsData() : offset(0), column_offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<optional_ptr<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t column_offset;
 };
@@ -90,12 +90,12 @@ unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, T
 
 class ColumnHelper {
 public:
-	static unique_ptr<ColumnHelper> Create(CatalogEntry *entry);
+	static unique_ptr<ColumnHelper> Create(CatalogEntry &entry);
 
 	virtual ~ColumnHelper() {
 	}
 
-	virtual StandardEntry *Entry() = 0;
+	virtual StandardEntry &Entry() = 0;
 	virtual idx_t NumColumns() = 0;
 	virtual const string &ColumnName(idx_t col) = 0;
 	virtual const LogicalType &ColumnType(idx_t col) = 0;
@@ -107,8 +107,8 @@ public:
 
 class TableColumnHelper : public ColumnHelper {
 public:
-	explicit TableColumnHelper(TableCatalogEntry *entry) : entry(entry) {
-		for (auto &constraint : entry->GetConstraints()) {
+	explicit TableColumnHelper(TableCatalogEntry &entry) : entry(entry) {
+		for (auto &constraint : entry.GetConstraints()) {
 			if (constraint->type == ConstraintType::NOT_NULL) {
 				auto &not_null = *reinterpret_cast<NotNullConstraint *>(constraint.get());
 				not_null_cols.insert(not_null.index.index);
@@ -116,20 +116,20 @@ public:
 		}
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->GetColumns().LogicalColumnCount();
+		return entry.GetColumns().LogicalColumnCount();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Name();
+		return entry.GetColumn(LogicalIndex(col)).Name();
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Type();
+		return entry.GetColumn(LogicalIndex(col)).Type();
 	}
 	const Value ColumnDefault(idx_t col) override {
-		auto &column = entry->GetColumn(LogicalIndex(col));
+		auto &column = entry.GetColumn(LogicalIndex(col));
 		if (column.DefaultValue()) {
 			return Value(column.DefaultValue()->ToString());
 		}
@@ -140,26 +140,26 @@ public:
 	}
 
 private:
-	TableCatalogEntry *entry;
+	TableCatalogEntry &entry;
 	std::set<idx_t> not_null_cols;
 };
 
 class ViewColumnHelper : public ColumnHelper {
 public:
-	explicit ViewColumnHelper(ViewCatalogEntry *entry) : entry(entry) {
+	explicit ViewColumnHelper(ViewCatalogEntry &entry) : entry(entry) {
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->types.size();
+		return entry.types.size();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->aliases[col];
+		return entry.aliases[col];
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->types[col];
+		return entry.types[col];
 	}
 	const Value ColumnDefault(idx_t col) override {
 		return Value();
@@ -169,15 +169,15 @@ public:
 	}
 
 private:
-	ViewCatalogEntry *entry;
+	ViewCatalogEntry &entry;
 };
 
-unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
-	switch (entry->type) {
+unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry &entry) {
+	switch (entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		return make_uniq<TableColumnHelper>((TableCatalogEntry *)entry);
+		return make_uniq<TableColumnHelper>(entry.Cast<TableCatalogEntry>());
 	case CatalogType::VIEW_ENTRY:
-		return make_uniq<ViewColumnHelper>((ViewCatalogEntry *)entry);
+		return make_uniq<ViewColumnHelper>(entry.Cast<ViewCatalogEntry>());
 	default:
 		throw NotImplementedException("Unsupported catalog type for duckdb_columns");
 	}
@@ -186,7 +186,7 @@ unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
 void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_col, DataChunk &output) {
 	for (idx_t i = start_col; i < end_col; i++) {
 		auto index = start_index + (i - start_col);
-		auto &entry = *Entry();
+		auto &entry = Entry();
 
 		idx_t col = 0;
 		// database_name, VARCHAR
@@ -284,7 +284,7 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 }
 
 void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBColumnsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBColumnsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -298,7 +298,7 @@ void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, D
 	idx_t column_offset = data.column_offset;
 	idx_t index = 0;
 	while (next < data.entries.size() && index < STANDARD_VECTOR_SIZE) {
-		auto column_helper = ColumnHelper::Create(data.entries[next]);
+		auto column_helper = ColumnHelper::Create(*data.entries[next]);
 		idx_t columns = column_helper->NumColumns();
 
 		// Check to see if we are going to exceed the maximum index for a DataChunk

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -19,7 +19,8 @@
 namespace duckdb {
 
 struct UniqueKeyInfo {
-	string schema, table;
+	string schema;
+	string table;
 	vector<LogicalIndex> columns;
 
 	bool operator==(const UniqueKeyInfo &other) const {
@@ -52,7 +53,7 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<optional_ptr<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
@@ -125,7 +126,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 }
 
 void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBConstraintsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBConstraintsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -134,10 +135,10 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
+		auto &entry = *data.entries[data.offset];
+		D_ASSERT(entry.type == CatalogType::TABLE_ENTRY);
 
-		auto &table = entry->Cast<TableCatalogEntry>();
+		auto &table = entry.Cast<TableCatalogEntry>();
 		auto &constraints = table.GetConstraints();
 		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {

package/src/duckdb/src/function/table/system/duckdb_databases.cpp

@@ -8,7 +8,7 @@ struct DuckDBDatabasesData : public GlobalTableFunctionState {
 	DuckDBDatabasesData() : offset(0) {
 	}
 
-	vector<AttachedDatabase *> entries;
+	vector<optional_ptr<AttachedDatabase>> entries;
 	idx_t offset;
 };
 

package/src/duckdb/src/function/table/system/duckdb_dependencies.cpp

@@ -9,8 +9,12 @@
 namespace duckdb {
 
 struct DependencyInformation {
-	CatalogEntry *object;
-	CatalogEntry *dependent;
+	DependencyInformation(CatalogEntry &object, CatalogEntry &dependent, DependencyType type)
+	    : object(object), dependent(dependent), type(type) {
+	}
+
+	CatalogEntry &object;
+	CatalogEntry &dependent;
 	DependencyType type;
 };
 
@@ -54,14 +58,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &conte
 	// scan all the schemas and collect them
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 	if (catalog.IsDuckCatalog()) {
-		auto &duck_catalog = (DuckCatalog &)catalog;
+		auto &duck_catalog = catalog.Cast<DuckCatalog>();
 		auto &dependency_manager = duck_catalog.GetDependencyManager();
-		dependency_manager.Scan([&](CatalogEntry *obj, CatalogEntry *dependent, DependencyType type) {
-			DependencyInformation info;
-			info.object = obj;
-			info.dependent = dependent;
-			info.type = type;
-			result->entries.push_back(info);
+		dependency_manager.Scan([&](CatalogEntry &obj, CatalogEntry &dependent, DependencyType type) {
+			result->entries.emplace_back(obj, dependent, type);
 		});
 	}
 
@@ -84,13 +84,13 @@ void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data
 		// classid, LogicalType::BIGINT
 		output.SetValue(0, count, Value::BIGINT(0));
 		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(entry.object->oid));
+		output.SetValue(1, count, Value::BIGINT(entry.object.oid));
 		// objsubid, LogicalType::INTEGER
 		output.SetValue(2, count, Value::INTEGER(0));
 		// refclassid, LogicalType::BIGINT
 		output.SetValue(3, count, Value::BIGINT(0));
 		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(entry.dependent->oid));
+		output.SetValue(4, count, Value::BIGINT(entry.dependent.oid));
 		// refobjsubid, LogicalType::INTEGER
 		output.SetValue(5, count, Value::INTEGER(0));
 		// deptype, LogicalType::VARCHAR

package/src/duckdb/src/function/table/system/pragma_database_size.cpp

@@ -15,7 +15,7 @@ struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	}
 
 	idx_t index;
-	vector<AttachedDatabase *> databases;
+	vector<optional_ptr<AttachedDatabase>> databases;
 	Value memory_usage;
 	Value memory_limit;
 };

package/src/duckdb/src/function/table/system/pragma_table_info.cpp

@@ -17,10 +17,10 @@
 namespace duckdb {
 
 struct PragmaTableFunctionData : public TableFunctionData {
-	explicit PragmaTableFunctionData(CatalogEntry *entry_p) : entry(entry_p) {
+	explicit PragmaTableFunctionData(CatalogEntry &entry_p) : entry(entry_p) {
 	}
 
-	CatalogEntry *entry;
+	CatalogEntry &entry;
 };
 
 struct PragmaTableOperatorData : public GlobalTableFunctionState {
@@ -55,20 +55,20 @@ static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, Tabl
 	// look up the table name in the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
 	auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	return make_uniq<PragmaTableFunctionData>(entry);
+	return make_uniq<PragmaTableFunctionData>(*entry);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_uniq<PragmaTableOperatorData>();
 }
 
-static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &column, bool &out_not_null,
+static void CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &column, bool &out_not_null,
                              bool &out_pk) {
 	out_not_null = false;
 	out_pk = false;
 	// check all constraints
 	// FIXME: this is pretty inefficient, it probably doesn't matter
-	for (auto &constraint : table->GetConstraints()) {
+	for (auto &constraint : table.GetConstraints()) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
 			auto &not_null = constraint->Cast<NotNullConstraint>();
@@ -79,7 +79,6 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 		}
 		case ConstraintType::UNIQUE: {
 			auto &unique = constraint->Cast<UniqueConstraint>();
-
 			if (unique.is_primary_key) {
 				if (unique.index == column.Logical()) {
 					out_pk = true;
@@ -96,20 +95,20 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 	}
 }
 
-static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry *table, DataChunk &output) {
-	if (data.offset >= table->GetColumns().LogicalColumnCount()) {
+static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry &table, DataChunk &output) {
+	if (data.offset >= table.GetColumns().LogicalColumnCount()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table->GetColumns().LogicalColumnCount());
+	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table.GetColumns().LogicalColumnCount());
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
 		bool not_null, pk;
 		auto index = i - data.offset;
-		auto &column = table->GetColumn(LogicalIndex(i));
+		auto &column = table.GetColumn(LogicalIndex(i));
 		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
 		CheckConstraints(table, column, not_null, pk);
 
@@ -131,20 +130,20 @@ static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntr
 	data.offset = next;
 }
 
-static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry *view, DataChunk &output) {
-	if (data.offset >= view->types.size()) {
+static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry &view, DataChunk &output) {
+	if (data.offset >= view.types.size()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view->types.size());
+	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view.types.size());
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
 		auto index = i - data.offset;
-		auto type = view->types[i];
-		auto &name = view->aliases[i];
+		auto type = view.types[i];
+		auto &name = view.aliases[i];
 		// return values:
 		// "cid", PhysicalType::INT32
 
@@ -166,12 +165,12 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (PragmaTableFunctionData &)*data_p.bind_data;
 	auto &state = data_p.global_state->Cast<PragmaTableOperatorData>();
-	switch (bind_data.entry->type) {
+	switch (bind_data.entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		PragmaTableInfoTable(state, (TableCatalogEntry *)bind_data.entry, output);
+		PragmaTableInfoTable(state, bind_data.entry.Cast<TableCatalogEntry>(), output);
 		break;
 	case CatalogType::VIEW_ENTRY:
-		PragmaTableInfoView(state, (ViewCatalogEntry *)bind_data.entry, output);
+		PragmaTableInfoView(state, bind_data.entry.Cast<ViewCatalogEntry>(), output);
 		break;
 	default:
 		throw NotImplementedException("Unimplemented catalog type for pragma_table_info");

package/src/duckdb/src/function/table/table_scan.cpp

@@ -185,7 +185,7 @@ BindInfo TableScanGetBindInfo(const FunctionData *bind_data) {
 
 void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	entries.AddDependency(bind_data.table);
+	entries.AddDependency(*bind_data.table);
 }
 
 unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
@@ -302,30 +302,27 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		ExpressionType low_comparison_type = ExpressionType::INVALID, high_comparison_type = ExpressionType::INVALID;
 		// try to find a matching index for any of the filter expressions
 		for (auto &filter : filters) {
-			auto expr = filter.get();
+			auto &expr = *filter;
 
 			// create a matcher for a comparison with a constant
 			ComparisonExpressionMatcher matcher;
 			// match on a comparison type
 			matcher.expr_type = make_uniq<ComparisonExpressionTypeMatcher>();
 			// match on a constant comparison with the indexed expression
-			matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(index_expression.get()));
+			matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(*index_expression));
 			matcher.matchers.push_back(make_uniq<ConstantExpressionMatcher>());
 
 			matcher.policy = SetMatcher::Policy::UNORDERED;
 
-			vector<Expression *> bindings;
+			vector<reference<Expression>> bindings;
 			if (matcher.Match(expr, bindings)) {
 				// range or equality comparison with constant value
 				// we can use our index here
 				// bindings[0] = the expression
 				// bindings[1] = the index expression
 				// bindings[2] = the constant
-				auto &comparison = bindings[0]->Cast<BoundComparisonExpression>();
-				D_ASSERT(bindings[0]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				D_ASSERT(bindings[2]->type == ExpressionType::VALUE_CONSTANT);
-
-				auto constant_value = bindings[2]->Cast<BoundConstantExpression>().value;
+				auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
+				auto constant_value = bindings[2].get().Cast<BoundConstantExpression>().value;
 				auto comparison_type = comparison.type;
 				if (comparison.left->type == ExpressionType::VALUE_CONSTANT) {
 					// the expression is on the right side, we flip them around
@@ -346,9 +343,9 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 					high_value = constant_value;
 					high_comparison_type = comparison_type;
 				}
-			} else if (expr->type == ExpressionType::COMPARE_BETWEEN) {
+			} else if (expr.type == ExpressionType::COMPARE_BETWEEN) {
 				// BETWEEN expression
-				auto &between = expr->Cast<BoundBetweenExpression>();
+				auto &between = expr.Cast<BoundBetweenExpression>();
 				if (!between.input->Equals(index_expression.get())) {
 					// expression doesn't match the current index expression
 					continue;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1734"
+#define DUCKDB_VERSION "0.7.2-dev1867"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "e8610c85fb"
+#define DUCKDB_SOURCE_ID "084890df27"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -146,31 +146,31 @@ public:
 	DUCKDB_API CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info);
 
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                     BoundCreateTableInfo *info);
 	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                             CreateTableFunctionInfo *info);
 	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                            CreateCopyFunctionInfo *info);
 	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API 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,
+	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                        CreateFunctionInfo *info);
 	//! Creates a view in the catalog
-	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                    CreateViewInfo *info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                        CreateSequenceInfo *info);
 	//! Creates a enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                    CreateTypeInfo *info);
 	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
 	                                         CreateCollationInfo *info);
 
 	//! Drops an entry from the catalog

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

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry_map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/unordered_map.hpp"
+
+namespace duckdb {
+class CatalogEntry;
+
+struct CatalogEntryHashFunction {
+	uint64_t operator()(const reference<CatalogEntry> &a) const {
+		std::hash<void *> hash_func;
+		return hash_func((void *)&a.get());
+	}
+};
+
+struct CatalogEntryEquality {
+	bool operator()(const reference<CatalogEntry> &a, const reference<CatalogEntry> &b) const {
+		return RefersToSameObject(a, b);
+	}
+};
+
+using catalog_entry_set_t = unordered_set<reference<CatalogEntry>, CatalogEntryHashFunction, CatalogEntryEquality>;
+
+template <typename T>
+using catalog_entry_map_t = unordered_map<reference<CatalogEntry>, T, CatalogEntryHashFunction, CatalogEntryEquality>;
+
+using catalog_entry_vector_t = vector<reference<CatalogEntry>>;
+
+} // namespace duckdb

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class Catalog;
@@ -20,9 +21,9 @@ struct CatalogTransaction {
 	CatalogTransaction(Catalog &catalog, ClientContext &context);
 	CatalogTransaction(DatabaseInstance &db, transaction_t transaction_id_p, transaction_t start_time_p);
 
-	DatabaseInstance *db;
-	ClientContext *context;
-	Transaction *transaction;
+	optional_ptr<DatabaseInstance> db;
+	optional_ptr<ClientContext> context;
+	optional_ptr<Transaction> transaction;
 	transaction_t transaction_id;
 	transaction_t start_time;
 

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

@@ -23,9 +23,9 @@ struct DefaultMacro {
 
 class DefaultFunctionGenerator : public DefaultGenerator {
 public:
-	DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
+	DefaultFunctionGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
 
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 
 	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(DefaultMacro &default_macro);
 	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro);

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

@@ -16,9 +16,9 @@ class SchemaCatalogEntry;
 
 class DefaultTypeGenerator : public DefaultGenerator {
 public:
-	DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
+	DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
 
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 
 public:
 	DUCKDB_API static LogicalTypeId GetDefaultType(const string &name);

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

@@ -16,9 +16,9 @@ class SchemaCatalogEntry;
 
 class DefaultViewGenerator : public DefaultGenerator {
 public:
-	DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry *schema);
+	DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry &schema);
 
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 
 public:
 	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;

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

@@ -22,13 +22,13 @@ enum class DependencyType {
 };
 
 struct Dependency {
-	Dependency(CatalogEntry *entry, DependencyType dependency_type = DependencyType::DEPENDENCY_REGULAR)
+	Dependency(CatalogEntry &entry, DependencyType dependency_type = DependencyType::DEPENDENCY_REGULAR)
 	    : // NOLINT: Allow implicit conversion from `CatalogEntry`
 	      entry(entry), dependency_type(dependency_type) {
 	}
 
 	//! The catalog entry this depends on
-	CatalogEntry *entry;
+	reference<CatalogEntry> entry;
 	//! The type of dependency
 	DependencyType dependency_type;
 };
@@ -36,16 +36,15 @@ struct Dependency {
 struct DependencyHashFunction {
 	uint64_t operator()(const Dependency &a) const {
 		std::hash<void *> hash_func;
-		return hash_func((void *)a.entry);
+		return hash_func((void *)&a.entry.get());
 	}
 };
 
 struct DependencyEquality {
 	bool operator()(const Dependency &a, const Dependency &b) const {
-		return a.entry == b.entry;
+		return RefersToSameObject(a.entry, b.entry);
 	}
 };
-
 using dependency_set_t = unordered_set<Dependency, DependencyHashFunction, DependencyEquality>;
 
 } // namespace duckdb

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

@@ -8,8 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/catalog/catalog_entry_map.hpp"
 
 namespace duckdb {
 class Catalog;
@@ -20,11 +19,11 @@ class DependencyList {
 	friend class DependencyManager;
 
 public:
-	DUCKDB_API void AddDependency(CatalogEntry *entry);
+	DUCKDB_API void AddDependency(CatalogEntry &entry);
 
-	DUCKDB_API void VerifyDependencies(Catalog *catalog, const string &name);
+	DUCKDB_API void VerifyDependencies(Catalog &catalog, const string &name);
 
 private:
-	unordered_set<CatalogEntry *> set;
+	catalog_entry_set_t set;
 };
 } // namespace duckdb