duckdb 0.7.2-dev1803.0 → 0.7.2-dev1898.0

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-dev1803"
+#define DUCKDB_VERSION "0.7.2-dev1898"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "cc6160599b"
+#define DUCKDB_SOURCE_ID "eaf507009f"
 #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

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

@@ -11,6 +11,7 @@
 #include "duckdb/catalog/catalog_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/dependency.hpp"
+#include "duckdb/catalog/catalog_entry_map.hpp"
 #include "duckdb/catalog/catalog_transaction.hpp"
 
 #include <functional>
@@ -28,26 +29,26 @@ public:
 	explicit DependencyManager(DuckCatalog &catalog);
 
 	//! Erase the object from the DependencyManager; this should only happen when the object itself is destroyed
-	void EraseObject(CatalogEntry *object);
+	void EraseObject(CatalogEntry &object);
 
 	//! Scans all dependencies, returning pairs of (object, dependent)
-	void Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback);
+	void Scan(const std::function<void(CatalogEntry &, CatalogEntry &, DependencyType)> &callback);
 
-	void AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry);
+	void AddOwnership(CatalogTransaction transaction, CatalogEntry &owner, CatalogEntry &entry);
 
 private:
 	DuckCatalog &catalog;
 	//! Map of objects that DEPEND on [object], i.e. [object] can only be deleted when all entries in the dependency map
 	//! are deleted.
-	unordered_map<CatalogEntry *, dependency_set_t> dependents_map;
+	catalog_entry_map_t<dependency_set_t> dependents_map;
 	//! Map of objects that the source object DEPENDS on, i.e. when any of the entries in the vector perform a CASCADE
 	//! drop then [object] is deleted as well
-	unordered_map<CatalogEntry *, unordered_set<CatalogEntry *>> dependencies_map;
+	catalog_entry_map_t<catalog_entry_set_t> dependencies_map;
 
 private:
-	void AddObject(CatalogTransaction transaction, CatalogEntry *object, DependencyList &dependencies);
-	void DropObject(CatalogTransaction transaction, CatalogEntry *object, bool cascade);
-	void AlterObject(CatalogTransaction transaction, CatalogEntry *old_obj, CatalogEntry *new_obj);
-	void EraseObjectInternal(CatalogEntry *object);
+	void AddObject(CatalogTransaction transaction, CatalogEntry &object, DependencyList &dependencies);
+	void DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade);
+	void AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj);
+	void EraseObjectInternal(CatalogEntry &object);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/allocator.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class Allocator;
@@ -56,7 +57,7 @@ public:
 	void Reset();
 
 private:
-	Allocator *allocator;
+	optional_ptr<Allocator> allocator;
 	data_ptr_t pointer;
 	idx_t allocated_size;
 };

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -167,7 +167,7 @@ public:
 		return root.GetContext();
 	}
 
-	Catalog *GetCatalog() override {
+	optional_ptr<Catalog> GetCatalog() override {
 		return root.GetCatalog();
 	}
 

package/src/duckdb/src/include/duckdb/common/helper.hpp

@@ -170,4 +170,13 @@ void AssignSharedPointer(shared_ptr<T> &target, const shared_ptr<T> &source) {
 	}
 }
 
+template<typename T>
+using reference = std::reference_wrapper<T>;
+
+//! Returns whether or not two reference wrappers refer to the same object
+template<class T>
+bool RefersToSameObject(const reference<T> &A, const reference<T> &B) {
+	return &A.get() == &B.get();
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/optional_ptr.hpp

@@ -22,19 +22,42 @@ public:
 	optional_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
 	}
 
+	void CheckValid() const {
+		if (!ptr) {
+			throw InternalException("Attempting to dereference an optional pointer that is not set");
+		}
+	}
+
 	operator bool() const {
 		return ptr;
 	}
 	T &operator*() {
-		if (!ptr) {
-			throw InternalException("Attempting to dereference an optional pointer that is not set");
-		}
+		CheckValid();
+		return *ptr;
+	}
+	const T &operator*() const {
+		CheckValid();
 		return *ptr;
 	}
 	T *operator->() {
-		if (!ptr) {
-			throw InternalException("Attempting to call a method on an optional pointer that is not set");
-		}
+		CheckValid();
+		return ptr;
+	}
+	const T *operator->() const {
+		CheckValid();
+		return ptr;
+	}
+	T *get() {
+		// CheckValid();
+		return ptr;
+	}
+	const T *get() const {
+		// CheckValid();
+		return ptr;
+	}
+	// this looks dirty - but this is the default behavior of raw pointers
+	T *get_mutable() const {
+		// CheckValid();
 		return ptr;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp

@@ -14,16 +14,14 @@ namespace duckdb {
 
 class BufferedFileReader : public Deserializer {
 public:
-	BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context,
-	                   FileLockType lock_type = FileLockType::READ_LOCK, FileOpener *opener = nullptr);
+	BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
+	                   FileLockType lock_type = FileLockType::READ_LOCK, optional_ptr<FileOpener> opener = nullptr);
 
 	FileSystem &fs;
 	unique_ptr<data_t[]> data;
 	idx_t offset;
 	idx_t read_data;
 	unique_ptr<FileHandle> handle;
-	ClientContext *context;
-	Catalog *catalog = nullptr;
 
 public:
 	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
@@ -39,11 +37,14 @@ public:
 
 	ClientContext &GetContext() override;
 
-	Catalog *GetCatalog() override;
+	optional_ptr<Catalog> GetCatalog() override;
+	void SetCatalog(Catalog &catalog);
 
 private:
 	idx_t file_size;
 	idx_t total_read;
+	optional_ptr<ClientContext> context;
+	optional_ptr<Catalog> catalog;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer.hpp

@@ -120,7 +120,7 @@ public:
 	};
 
 	//! Gets the catalog for the deserializer
-	virtual Catalog *GetCatalog() {
+	virtual optional_ptr<Catalog> GetCatalog() {
 		return nullptr;
 	};
 

package/src/duckdb/src/include/duckdb/common/types/row_data_collection.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp

@@ -22,7 +22,7 @@ public:
 	                    physical_index_vector_t<idx_t> column_index_map, vector<unique_ptr<Expression>> bound_defaults,
 	                    idx_t estimated_cardinality);
 	//! CREATE TABLE AS
-	PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
+	PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
 	                    idx_t estimated_cardinality);
 
 	//! The map from insert column index to table column index
@@ -34,7 +34,7 @@ public:
 	//! The default expressions of the columns for which no value is provided
 	vector<unique_ptr<Expression>> bound_defaults;
 	//! Table schema, in case of CREATE TABLE AS
-	SchemaCatalogEntry *schema;
+	optional_ptr<SchemaCatalogEntry> schema;
 	//! Create table info, in case of CREATE TABLE AS
 	unique_ptr<BoundCreateTableInfo> info;
 	// Which action to perform on conflict

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp

@@ -32,7 +32,7 @@ public:
 	               unique_ptr<Expression> on_conflict_condition, unique_ptr<Expression> do_update_condition,
 	               unordered_set<column_t> on_conflict_filter, vector<column_t> columns_to_fetch);
 	//! CREATE TABLE AS
-	PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
+	PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
 	               idx_t estimated_cardinality, bool parallel);
 
 	//! The map from insert column index to table column index
@@ -46,7 +46,7 @@ public:
 	//! If the returning statement is present, return the whole chunk
 	bool return_chunk;
 	//! Table schema, in case of CREATE TABLE AS
-	SchemaCatalogEntry *schema;
+	optional_ptr<SchemaCatalogEntry> schema;
 	//! Create table info, in case of CREATE TABLE AS
 	unique_ptr<BoundCreateTableInfo> info;
 	//! Whether or not the INSERT can be executed in parallel
@@ -109,15 +109,15 @@ public:
 public:
 	static void GetInsertInfo(const BoundCreateTableInfo &info, vector<LogicalType> &insert_types,
 	                          vector<unique_ptr<Expression>> &bound_defaults);
-	static void ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
+	static void ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
 	                            const physical_index_vector_t<idx_t> &column_index_map,
 	                            ExpressionExecutor &defaults_executor, DataChunk &result);
 
 protected:
 	void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
 	                                    ClientContext &client) const;
-	void OnConflictHandling(TableCatalogEntry *table, ExecutionContext &context, InsertLocalState &lstate) const;
-	void PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry *table,
+	void OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const;
+	void PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
 	                             Vector &row_ids) const;
 	void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) const;
 };

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp

@@ -19,11 +19,11 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TABLE;
 
 public:
-	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
+	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
 	                    idx_t estimated_cardinality);
 
 	//! Schema to insert to
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 	//! Table name to create
 	unique_ptr<BoundCreateTableInfo> info;