duckdb 0.7.2-dev1803.0 → 0.7.2-dev1867.0

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-dev1867"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "cc6160599b"
+#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

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;
 

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -97,10 +97,11 @@ public:
 };
 
 struct BindCastInput {
-	DUCKDB_API BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, optional_ptr<ClientContext> context);
+	DUCKDB_API BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
+	                         optional_ptr<ClientContext> context);
 
 	CastFunctionSet &function_set;
-	BindCastInfo *info;
+	optional_ptr<BindCastInfo> info;
 	optional_ptr<ClientContext> context;
 
 public:

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -205,6 +205,10 @@ struct LevenshteinFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DamerauLevenshteinFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct JaccardFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -35,7 +36,7 @@ public:
 
 	void InitializeSystemCatalog();
 	//! Get an attached database with the given name
-	AttachedDatabase *GetDatabase(ClientContext &context, const string &name);
+	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);
@@ -43,8 +44,8 @@ public:
 	Catalog &GetSystemCatalog();
 	static const string &GetDefaultDatabase(ClientContext &context);
 
-	AttachedDatabase *GetDatabaseFromPath(ClientContext &context, const string &path);
-	vector<AttachedDatabase *> GetDatabases(ClientContext &context);
+	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
+	vector<optional_ptr<AttachedDatabase>> GetDatabases(ClientContext &context);
 
 	transaction_t GetNewQueryNumber() {
 		return current_query_number++;

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

@@ -131,7 +131,8 @@ private:
 	//! The row-based query result iterator. Invoking the
 	class QueryResultIterator {
 	public:
-		explicit QueryResultIterator(QueryResult *result_p) : current_row(*this, 0), result(result_p), base_row(0) {
+		explicit QueryResultIterator(optional_ptr<QueryResult> result_p)
+		    : current_row(*this, 0), result(result_p), base_row(0) {
 			if (result) {
 				chunk = shared_ptr<DataChunk>(result->Fetch().release());
 				if (!chunk) {
@@ -142,7 +143,7 @@ private:
 
 		QueryResultRow current_row;
 		shared_ptr<DataChunk> chunk;
-		QueryResult *result;
+		optional_ptr<QueryResult> result;
 		idx_t base_row;
 
 	public:

package/src/duckdb/src/include/duckdb/optimizer/filter_combiner.hpp

@@ -52,14 +52,14 @@ public:
 	// &pushed_filters);
 
 private:
-	FilterResult AddFilter(Expression *expr);
-	FilterResult AddBoundComparisonFilter(Expression *expr);
+	FilterResult AddFilter(Expression &expr);
+	FilterResult AddBoundComparisonFilter(Expression &expr);
 	FilterResult AddTransitiveFilters(BoundComparisonExpression &comparison);
-	unique_ptr<Expression> FindTransitiveFilter(Expression *expr);
+	unique_ptr<Expression> FindTransitiveFilter(Expression &expr);
 	// unordered_map<idx_t, std::pair<Value *, Value *>>
 	// FindZonemapChecks(vector<idx_t> &column_ids, unordered_set<idx_t> &not_constants, Expression *filter);
-	Expression *GetNode(Expression *expr);
-	idx_t GetEquivalenceSet(Expression *expr);
+	Expression &GetNode(Expression &expr);
+	idx_t GetEquivalenceSet(Expression &expr);
 	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
 	//
 	//	//! Functions used to push and generate OR Filters
@@ -97,9 +97,9 @@ private:
 	vector<unique_ptr<Expression>> remaining_filters;
 
 	expression_map_t<unique_ptr<Expression>> stored_expressions;
-	unordered_map<Expression *, idx_t> equivalence_set_map;
+	expression_map_t<idx_t> equivalence_set_map;
 	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
-	unordered_map<idx_t, vector<Expression *>> equivalence_map;
+	unordered_map<idx_t, vector<reference<Expression>>> equivalence_map;
 	idx_t set_index = 0;
 	//
 	//	//! Structures used for OR Filters