duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

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

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/aggregate_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/storage/statistics/node_statistics.hpp"
+
+namespace duckdb {
+
+enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
+//! Whether or not the input order influences the result of the aggregate
+enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
+
+class BoundAggregateExpression;
+
+struct AggregateInputData {
+	AggregateInputData(optional_ptr<FunctionData> bind_data_p, Allocator &allocator_p)
+	    : bind_data(bind_data_p), allocator(allocator_p) {
+	}
+	optional_ptr<FunctionData> bind_data;
+	Allocator &allocator;
+};
+
+struct AggregateUnaryInput {
+	AggregateUnaryInput(AggregateInputData &input_p, ValidityMask &input_mask_p)
+	    : input(input_p), input_mask(input_mask_p), input_idx(0) {
+	}
+
+	AggregateInputData &input;
+	ValidityMask &input_mask;
+	idx_t input_idx;
+
+	inline bool RowIsValid() {
+		return input_mask.RowIsValid(input_idx);
+	}
+};
+
+struct AggregateBinaryInput {
+	AggregateBinaryInput(AggregateInputData &input_p, ValidityMask &left_mask_p, ValidityMask &right_mask_p)
+	    : input(input_p), left_mask(left_mask_p), right_mask(right_mask_p) {
+	}
+
+	AggregateInputData &input;
+	ValidityMask &left_mask;
+	ValidityMask &right_mask;
+	idx_t lidx;
+	idx_t ridx;
+};
+
+struct AggregateFinalizeData {
+	AggregateFinalizeData(Vector &result_p, AggregateInputData &input_p)
+	    : result(result_p), input(input_p), result_idx(0) {
+	}
+
+	Vector &result;
+	AggregateInputData &input;
+	idx_t result_idx;
+
+	inline void ReturnNull() {
+		switch (result.GetVectorType()) {
+		case VectorType::FLAT_VECTOR:
+			FlatVector::SetNull(result, result_idx, true);
+			break;
+		case VectorType::CONSTANT_VECTOR:
+			ConstantVector::SetNull(result, true);
+			break;
+		default:
+			throw InternalException("Invalid result vector type for aggregate");
+		}
+	}
+
+	inline string_t ReturnString(string_t value) {
+		return StringVector::AddStringOrBlob(result, value);
+	}
+};
+
+struct AggregateStatisticsInput {
+	AggregateStatisticsInput(optional_ptr<FunctionData> bind_data_p, vector<BaseStatistics> &child_stats_p,
+	                         optional_ptr<NodeStatistics> node_stats_p)
+	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
+	}
+
+	optional_ptr<FunctionData> bind_data;
+	vector<BaseStatistics> &child_stats;
+	optional_ptr<NodeStatistics> node_stats;
+};
+
+} // namespace duckdb

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

@@ -22,6 +22,17 @@ struct FunctionLocalState;
 //! Extra data that can be attached to a bind function of a cast, and is available during binding
 struct BindCastInfo {
 	DUCKDB_API virtual ~BindCastInfo();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 //! Extra data that can be returned by the bind of a cast, and is available during execution of a cast
@@ -33,12 +44,12 @@ struct BoundCastData {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -201,15 +201,15 @@ struct VectorCastHelpers {
 struct VectorStringToList {
 	static idx_t CountPartsList(const string_t &input);
 	static bool SplitStringList(const string_t &input, string_t *child_data, idx_t &child_start, Vector &child);
-	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
 	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
 	                                       const SelectionVector *sel);
 };
 
 struct VectorStringToStruct {
-	static bool SplitStruct(string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
+	static bool SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
 	                        string_map_t<idx_t> &child_names, vector<ValidityMask *> &child_masks);
-	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
 	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
 	                                       const SelectionVector *sel);
 };
@@ -218,7 +218,7 @@ struct VectorStringToMap {
 	static idx_t CountPartsMap(const string_t &input);
 	static bool SplitStringMap(const string_t &input, string_t *child_key_data, string_t *child_val_data,
 	                           idx_t &child_start, Vector &varchar_key, Vector &varchar_val);
-	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	static bool StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask, Vector &result,
 	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
 	                                       const SelectionVector *sel);
 };

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

@@ -29,16 +29,49 @@ struct SegmentScanState;
 struct AnalyzeState {
 	virtual ~AnalyzeState() {
 	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct CompressionState {
 	virtual ~CompressionState() {
 	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct CompressedSegmentState {
 	virtual ~CompressedSegmentState() {
 	}
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct CompressionAppendState {
@@ -48,6 +81,17 @@ struct CompressionAppendState {
 	}
 
 	BufferHandle handle;
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 //===--------------------------------------------------------------------===//

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

@@ -27,12 +27,12 @@ struct LocalFunctionData {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -43,12 +43,12 @@ struct GlobalFunctionData {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -59,12 +59,12 @@ struct PreparedBatchData {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -49,17 +49,17 @@ struct FunctionData {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 	// FIXME: this function should be removed in the future
 	template <class TARGET>
 	TARGET &CastNoConst() const {
-		return (TARGET &)*this;
+		return const_cast<TARGET &>(reinterpret_cast<const TARGET &>(*this));
 	}
 };
 

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

@@ -25,8 +25,10 @@ public:
 		bool serialize = function.serialize;
 		writer.WriteField(serialize);
 		if (serialize) {
-			D_ASSERT(function.deserialize);
 			function.serialize(writer, bind_info, function);
+			// First check if serialize throws a NotImplementedException, in which case it doesn't require a deserialize
+			// function
+			D_ASSERT(function.deserialize);
 		}
 	}
 

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

@@ -57,7 +57,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast macro to type - macro type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -65,7 +65,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast macro to type - macro type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp

@@ -27,14 +27,14 @@ static void TemplatedContainsOrPosition(DataChunk &args, Vector &result, bool is
 
 	UnifiedVectorFormat list_data;
 	list.ToUnifiedFormat(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
 
 	UnifiedVectorFormat value_data;
 	value_vector.ToUnifiedFormat(count, value_data);
 
 	// not required for a comparison of nested types
-	auto child_value = (CHILD_TYPE *)child_data.data;
-	auto values = (CHILD_TYPE *)value_data.data;
+	auto child_value = UnifiedVectorFormat::GetData<CHILD_TYPE>(child_data);
+	auto values = UnifiedVectorFormat::GetData<CHILD_TYPE>(value_data);
 
 	for (idx_t i = 0; i < count; i++) {
 		auto list_index = list_data.sel->get_index(i);

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

@@ -25,12 +25,12 @@ struct FunctionLocalState {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -9,12 +9,12 @@
 #pragma once
 
 #include "duckdb/common/enums/operator_result_type.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
-#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -31,12 +31,12 @@ struct TableFunctionInfo {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -55,12 +55,12 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -70,12 +70,12 @@ struct LocalTableFunctionState {
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -265,6 +265,7 @@ public:
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;
+	bool verify_serialization = true;
 
 	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added
 	//! that filters out unused columns.

package/src/duckdb/src/include/duckdb/main/capi/cast/utils.hpp

@@ -82,7 +82,7 @@ struct ToCStringCastWrapper {
 		auto result_size = result_string.GetSize();
 		auto result_data = result_string.GetData();
 
-		char *allocated_data = (char *)duckdb_malloc(result_size + 1);
+		char *allocated_data = char_ptr_cast(duckdb_malloc(result_size + 1));
 		memcpy(allocated_data, result_data, result_size);
 		allocated_data[result_size] = '\0';
 		result.data = allocated_data;

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

@@ -151,6 +151,8 @@ struct DBConfigOptions {
 	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
 	//! The set of unrecognized (other) options
 	unordered_map<string, Value> unrecognized_options;
+	//! Whether or not the configuration settings can be altered
+	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
 	static bool debug_print_bindings;
 

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

@@ -17,6 +17,9 @@ namespace duckdb {
 class ClientContext;
 
 class MaterializedQueryResult : public QueryResult {
+public:
+	static constexpr const QueryResultType TYPE = QueryResultType::MATERIALIZED_RESULT;
+
 public:
 	friend class ClientContext;
 	//! Creates a successful query result with the specified names and types

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

@@ -20,6 +20,9 @@ class PreparedStatementData;
 class PendingQueryResult : public BaseQueryResult {
 	friend class ClientContext;
 
+public:
+	static constexpr const QueryResultType TYPE = QueryResultType::PENDING_RESULT;
+
 public:
 	DUCKDB_API PendingQueryResult(shared_ptr<ClientContext> context, PreparedStatementData &statement,
 	                              vector<LogicalType> types, bool allow_stream_result);

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

@@ -89,6 +89,23 @@ public:
 	//! To comply, we use the following variable to store the current chunk, and it's position.
 	CurrentChunk current_chunk;
 
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast query result to type - query result type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast query result to type - query result type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 public:
 	//! Returns the name of the column for the given index
 	DUCKDB_API const string &ColumnName(idx_t index) const;

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

@@ -163,6 +163,18 @@ public:
 
 protected:
 	DUCKDB_API string RenderWhitespace(idx_t depth);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 } // namespace duckdb

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

@@ -309,6 +309,15 @@ struct LogQueryPathSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct LockConfigurationSetting {
+	static constexpr const char *Name = "lock_configuration";
+	static constexpr const char *Description = "Whether or not the configuration can be altered";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ImmediateTransactionModeSetting {
 	static constexpr const char *Name = "immediate_transaction_mode";
 	static constexpr const char *Description =

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

@@ -22,6 +22,9 @@ class PreparedStatementData;
 class StreamQueryResult : public QueryResult {
 	friend class ClientContext;
 
+public:
+	static constexpr const QueryResultType TYPE = QueryResultType::STREAM_RESULT;
+
 public:
 	//! Create a successful StreamQueryResult. StreamQueryResults should always be successful initially (it makes no
 	//! sense to stream an error).

package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp

@@ -111,9 +111,9 @@ private:
 	void AddRelationTdom(FilterInfo &filter_info);
 	bool EmptyFilter(FilterInfo &filter_info);
 
-	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *fil,
+	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &fil,
 	                            unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *fil,
+	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &fil,
 	                           unique_ptr<BaseStatistics> base_stats);
 	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator &op, TableFilterSet &table_filters, idx_t table_index);
 };

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

@@ -71,19 +71,13 @@ public:
 	//! Expression::Equals() returns true), that their hash value is identical as well.
 	virtual hash_t Hash() const = 0;
 	//! Returns true if this expression is equal to another expression
-	virtual bool Equals(const BaseExpression *other) const;
+	virtual bool Equals(const BaseExpression &other) const;
 
-	static bool Equals(const BaseExpression *left, const BaseExpression *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(right);
+	static bool Equals(const BaseExpression &left, const BaseExpression &right) {
+		return left.Equals(right);
 	}
 	bool operator==(const BaseExpression &rhs) {
-		return this->Equals(&rhs);
+		return Equals(rhs);
 	}
 
 	virtual void Verify() const;
@@ -94,7 +88,7 @@ public:
 		if (expression_class != TARGET::TYPE) {
 			throw InternalException("Failed to cast expression to type - expression type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -102,7 +96,7 @@ public:
 		if (expression_class != TARGET::TYPE) {
 			throw InternalException("Failed to cast expression to type - expression type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -74,7 +74,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -82,7 +82,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 } // namespace duckdb

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

@@ -27,7 +27,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equal(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equal(const BetweenExpression &a, const BetweenExpression &b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -32,7 +32,7 @@ public:
 
 	string ToString() const override;
 
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

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

@@ -35,7 +35,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equal(const CaseExpression *a, const CaseExpression *b);
+	static bool Equal(const CaseExpression &a, const CaseExpression &b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -31,7 +31,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equal(const CastExpression *a, const CastExpression *b);
+	static bool Equal(const CastExpression &a, const CastExpression &b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -28,7 +28,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equal(const CollateExpression *a, const CollateExpression *b);
+	static bool Equal(const CollateExpression &a, const CollateExpression &b);
 
 	unique_ptr<ParsedExpression> Copy() const override;