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

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/bit_utils.hpp

@@ -0,0 +1,147 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/bit_utils.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/hugeint.hpp"
+
+#ifdef _MSC_VER
+#define __restrict__
+#define __BYTE_ORDER__          __ORDER_LITTLE_ENDIAN__
+#define __ORDER_LITTLE_ENDIAN__ 2
+#include <intrin.h>
+static inline int __builtin_ctzll(unsigned long long x) {
+#ifdef _WIN64
+	unsigned long ret;
+	_BitScanForward64(&ret, x);
+	return (int)ret;
+#else
+	unsigned long low, high;
+	bool low_set = _BitScanForward(&low, (unsigned __int32)(x)) != 0;
+	_BitScanForward(&high, (unsigned __int32)(x >> 32));
+	high += 32;
+	return low_set ? low : high;
+#endif
+}
+static inline int __builtin_clzll(unsigned long long mask) {
+	unsigned long where;
+// BitScanReverse scans from MSB to LSB for first set bit.
+// Returns 0 if no set bit is found.
+#if defined(_WIN64)
+	if (_BitScanReverse64(&where, mask))
+		return static_cast<int>(63 - where);
+#elif defined(_WIN32)
+	// Scan the high 32 bits.
+	if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
+		return static_cast<int>(63 - (where + 32)); // Create a bit offset from the MSB.
+	// Scan the low 32 bits.
+	if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
+		return static_cast<int>(63 - where);
+#else
+#error "Implementation of __builtin_clzll required"
+#endif
+	return 64; // Undefined Behavior.
+}
+
+static inline int __builtin_ctz(unsigned int value) {
+	unsigned long trailing_zero = 0;
+
+	if (_BitScanForward(&trailing_zero, value)) {
+		return trailing_zero;
+	} else {
+		// This is undefined, I better choose 32 than 0
+		return 32;
+	}
+}
+
+static inline int __builtin_clz(unsigned int value) {
+	unsigned long leading_zero = 0;
+
+	if (_BitScanReverse(&leading_zero, value)) {
+		return 31 - leading_zero;
+	} else {
+		// Same remarks as above
+		return 32;
+	}
+}
+
+#endif
+
+namespace duckdb {
+
+template <class T>
+struct CountZeros {};
+
+template <>
+struct CountZeros<uint32_t> {
+	inline static int Leading(uint32_t value) {
+		if (!value) {
+			return 32;
+		}
+		return __builtin_clz(value);
+	}
+	inline static int Trailing(uint32_t value) {
+		if (!value) {
+			return 32;
+		}
+		return __builtin_ctz(value);
+	}
+};
+
+template <>
+struct CountZeros<uint64_t> {
+	inline static int Leading(uint64_t value) {
+		if (!value) {
+			return 64;
+		}
+		return __builtin_clzll(value);
+	}
+	inline static int Trailing(uint64_t value) {
+		if (!value) {
+			return 64;
+		}
+		return __builtin_ctzll(value);
+	}
+};
+
+template <>
+struct CountZeros<hugeint_t> {
+	inline static int Leading(hugeint_t value) {
+		if (value == 0) {
+			return 128;
+		}
+
+		uint64_t upper = (uint64_t)value.upper;
+		uint64_t lower = value.lower;
+
+		int res = __builtin_clzll(upper);
+		if (res == 64) {
+			res += __builtin_clzll(lower);
+		}
+
+		return res;
+	}
+
+	inline static int Trailing(hugeint_t value) {
+		if (value == 0) {
+			return 128;
+		}
+
+		uint64_t upper = (uint64_t)value.upper;
+		uint64_t lower = value.lower;
+
+		int res = __builtin_ctzll(lower);
+		if (res == 64) {
+			res += __builtin_ctzll(upper);
+		}
+
+		return res;
+	}
+};
+
+} // namespace duckdb

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/hugeint.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/string.hpp"
 #include <stdint.h>
 
 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/string_util.hpp

@@ -38,6 +38,13 @@ public:
 		throw InvalidInputException("Invalid input for hex digit: %s", string(c, 1));
 	}
 
+	static uint8_t GetBinaryValue(char c) {
+		if (c >= '0' && c <= '1') {
+			return c - '0';
+		}
+		throw InvalidInputException("Invalid input for binary digit: %s", string(c, 1));
+	}
+
 	DUCKDB_API static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}

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/common/types.hpp

@@ -387,7 +387,7 @@ public:
 	DUCKDB_API static LogicalType DECIMAL(int width, int scale);                 // NOLINT
 	DUCKDB_API static LogicalType VARCHAR_COLLATION(string collation);           // NOLINT
 	DUCKDB_API static LogicalType LIST(const LogicalType &child);                       // NOLINT
-	DUCKDB_API static LogicalType STRUCT(const child_list_t<LogicalType> &children);    // NOLINT
+	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
 	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
 	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT

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/math_functions.hpp

@@ -30,6 +30,10 @@ struct FloorFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct TruncFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct RoundFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

package/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp

@@ -27,7 +27,7 @@ public:
 
 	//! Checks if the given expression matches this ExpressionMatcher. If it does, the expression is appended to the
 	//! bindings list and true is returned. Otherwise, false is returned.
-	virtual bool Match(Expression *expr, vector<Expression *> &bindings);
+	virtual bool Match(Expression &expr, vector<reference<Expression>> &bindings);
 
 	//! The ExpressionClass of the to-be-matched expression. ExpressionClass::INVALID for ANY.
 	ExpressionClass expr_class;
@@ -40,14 +40,14 @@ public:
 //! The ExpressionEqualityMatcher matches on equality with another (given) expression
 class ExpressionEqualityMatcher : public ExpressionMatcher {
 public:
-	explicit ExpressionEqualityMatcher(Expression *expr)
+	explicit ExpressionEqualityMatcher(Expression &expr)
 	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 
 private:
-	Expression *expression;
+	const Expression &expression;
 };
 
 class ConstantExpressionMatcher : public ExpressionMatcher {
@@ -61,7 +61,7 @@ public:
 	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
 	}
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ComparisonExpressionMatcher : public ExpressionMatcher {
@@ -74,7 +74,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class CastExpressionMatcher : public ExpressionMatcher {
@@ -84,7 +84,7 @@ public:
 	//! The matcher for the child expressions
 	unique_ptr<ExpressionMatcher> matcher;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class InClauseExpressionMatcher : public ExpressionMatcher {
@@ -96,7 +96,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ConjunctionExpressionMatcher : public ExpressionMatcher {
@@ -109,7 +109,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class FunctionExpressionMatcher : public ExpressionMatcher {
@@ -123,7 +123,7 @@ public:
 	//! The function name to match
 	unique_ptr<FunctionMatcher> function;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 //! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.
@@ -133,7 +133,7 @@ public:
 	FoldableConstantMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 } // namespace duckdb