duckdb 0.8.1-dev65.0 → 0.8.1

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

@@ -17,142 +17,148 @@ struct ExtensionEntry {
 	char extension[48];
 };
 
-static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
-    {"->>", "json"},
-    {"array_to_json", "json"},
-    {"create_fts_index", "fts"},
-    {"current_localtime", "icu"},
-    {"current_localtimestamp", "icu"},
-    {"dbgen", "tpch"},
-    {"drop_fts_index", "fts"},
-    {"dsdgen", "tpcds"},
-    {"excel_text", "excel"},
-    {"from_json", "json"},
-    {"from_json_strict", "json"},
-    {"from_substrait", "substrait"},
-    {"from_substrait_json", "substrait"},
-    {"get_substrait", "substrait"},
-    {"get_substrait_json", "substrait"},
-    {"icu_calendar_names", "icu"},
-    {"icu_sort_key", "icu"},
-    {"json", "json"},
-    {"json_array", "json"},
-    {"json_array_length", "json"},
-    {"json_contains", "json"},
-    {"json_extract", "json"},
-    {"json_extract_path", "json"},
-    {"json_extract_path_text", "json"},
-    {"json_extract_string", "json"},
-    {"json_group_array", "json"},
-    {"json_group_object", "json"},
-    {"json_group_structure", "json"},
-    {"json_keys", "json"},
-    {"json_merge_patch", "json"},
-    {"json_object", "json"},
-    {"json_quote", "json"},
-    {"json_structure", "json"},
-    {"json_transform", "json"},
-    {"json_transform_strict", "json"},
-    {"json_type", "json"},
-    {"json_valid", "json"},
-    {"json_serialize_sql", "json"},
-    {"json_deserialize_sql", "json"},
-    {"json_serialize_sql", "json"},
-    {"json_execute_serialized_sql", "json"},
-    {"make_timestamptz", "icu"},
-    {"parquet_metadata", "parquet"},
-    {"parquet_scan", "parquet"},
-    {"parquet_schema", "parquet"},
-    {"pg_timezone_names", "icu"},
-    {"postgres_attach", "postgres_scanner"},
-    {"postgres_scan", "postgres_scanner"},
-    {"postgres_scan_pushdown", "postgres_scanner"},
-    {"read_json", "json"},
-    {"read_json_auto", "json"},
-    {"read_json_objects", "json"},
-    {"read_json_objects_auto", "json"},
-    {"read_ndjson", "json"},
-    {"read_ndjson_auto", "json"},
-    {"read_ndjson_objects", "json"},
-    {"read_parquet", "parquet"},
-    {"row_to_json", "json"},
-    {"scan_arrow_ipc", "arrow"},
-    {"sqlite_attach", "sqlite_scanner"},
-    {"sqlite_scan", "sqlite_scanner"},
-    {"stem", "fts"},
-    {"text", "excel"},
-    {"to_arrow_ipc", "arrow"},
-    {"to_json", "json"},
-    {"tpcds", "tpcds"},
-    {"tpcds_answers", "tpcds"},
-    {"tpcds_queries", "tpcds"},
-    {"tpch", "tpch"},
-    {"tpch_answers", "tpch"},
-    {"tpch_queries", "tpch"},
-    {"visualize_diff_profiling_output", "visualizer"},
-    {"visualize_json_profiling_output", "visualizer"},
-    {"visualize_last_profiling_output", "visualizer"},
-    {"st_distance_spheroid", "spatial"},
-    {"st_boundary", "spatial"},
-    {"st_makeline", "spatial"},
-    {"st_buffer", "spatial"},
-    {"st_x", "spatial"},
-    {"st_isring", "spatial"},
-    {"st_centroid", "spatial"},
-    {"st_read", "spatial"},
-    {"st_geomfromwkb", "spatial"},
-    {"st_list_proj_crs", "spatial"},
-    {"st_isvalid", "spatial"},
-    {"st_polygon2dfromwkb", "spatial"},
-    {"st_disjoint", "spatial"},
-    {"st_length", "spatial"},
-    {"st_difference", "spatial"},
-    {"st_area", "spatial"},
-    {"st_union", "spatial"},
-    {"st_isclosed", "spatial"},
-    {"st_asgeojson", "spatial"},
-    {"st_intersection", "spatial"},
-    {"st_transform", "spatial"},
-    {"st_dwithin", "spatial"},
-    {"st_perimeter", "spatial"},
-    {"st_issimple", "spatial"},
-    {"st_geometrytype", "spatial"},
-    {"st_simplifypreservetopology", "spatial"},
-    {"st_distance", "spatial"},
-    {"st_astext", "spatial"},
-    {"st_overlaps", "spatial"},
-    {"st_convexhull", "spatial"},
-    {"st_normalize", "spatial"},
-    {"st_drivers", "spatial"},
-    {"st_point2dfromwkb", "spatial"},
-    {"st_point2d", "spatial"},
-    {"st_y", "spatial"},
-    {"st_dwithin_spheroid", "spatial"},
-    {"st_isempty", "spatial"},
-    {"st_simplify", "spatial"},
-    {"st_area_spheroid", "spatial"},
-    {"st_within", "spatial"},
-    {"st_length_spheroid", "spatial"},
-    {"st_point3d", "spatial"},
-    {"st_containsproperly", "spatial"},
-    {"st_contains", "spatial"},
-    {"st_collect", "spatial"},
-    {"st_touches", "spatial"},
-    {"st_linestring2dfromwkb", "spatial"},
-    {"st_flipcoordinates", "spatial"},
-    {"st_ashexwkb", "spatial"},
-    {"st_geomfromtext", "spatial"},
-    {"st_point4d", "spatial"},
-    {"st_point", "spatial"},
-    {"st_coveredby", "spatial"},
-    {"st_perimeter_spheroid", "spatial"},
-    {"st_intersects", "spatial"},
-    {"st_crosses", "spatial"},
-    {"st_covers", "spatial"},
-    {"st_envelope", "spatial"},
-    {"st_aswkb", "spatial"},
-    {"st_equals", "spatial"},
-};
+static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
+                                                         {"array_to_json", "json"},
+                                                         {"create_fts_index", "fts"},
+                                                         {"current_localtime", "icu"},
+                                                         {"current_localtimestamp", "icu"},
+                                                         {"dbgen", "tpch"},
+                                                         {"drop_fts_index", "fts"},
+                                                         {"dsdgen", "tpcds"},
+                                                         {"excel_text", "excel"},
+                                                         {"from_json", "json"},
+                                                         {"from_json_strict", "json"},
+                                                         {"from_substrait", "substrait"},
+                                                         {"from_substrait_json", "substrait"},
+                                                         {"get_substrait", "substrait"},
+                                                         {"get_substrait_json", "substrait"},
+                                                         {"icu_calendar_names", "icu"},
+                                                         {"icu_sort_key", "icu"},
+                                                         {"json", "json"},
+                                                         {"json_array", "json"},
+                                                         {"json_array_length", "json"},
+                                                         {"json_contains", "json"},
+                                                         {"json_extract", "json"},
+                                                         {"json_extract_path", "json"},
+                                                         {"json_extract_path_text", "json"},
+                                                         {"json_extract_string", "json"},
+                                                         {"json_group_array", "json"},
+                                                         {"json_group_object", "json"},
+                                                         {"json_group_structure", "json"},
+                                                         {"json_keys", "json"},
+                                                         {"json_merge_patch", "json"},
+                                                         {"json_object", "json"},
+                                                         {"json_quote", "json"},
+                                                         {"json_structure", "json"},
+                                                         {"json_transform", "json"},
+                                                         {"json_transform_strict", "json"},
+                                                         {"json_type", "json"},
+                                                         {"json_valid", "json"},
+                                                         {"json_serialize_sql", "json"},
+                                                         {"json_deserialize_sql", "json"},
+                                                         {"json_serialize_sql", "json"},
+                                                         {"json_execute_serialized_sql", "json"},
+                                                         {"make_timestamptz", "icu"},
+                                                         {"parquet_metadata", "parquet"},
+                                                         {"parquet_scan", "parquet"},
+                                                         {"parquet_schema", "parquet"},
+                                                         {"pg_timezone_names", "icu"},
+                                                         {"postgres_attach", "postgres_scanner"},
+                                                         {"postgres_scan", "postgres_scanner"},
+                                                         {"postgres_scan_pushdown", "postgres_scanner"},
+                                                         {"read_json", "json"},
+                                                         {"read_json_auto", "json"},
+                                                         {"read_json_objects", "json"},
+                                                         {"read_json_objects_auto", "json"},
+                                                         {"read_ndjson", "json"},
+                                                         {"read_ndjson_auto", "json"},
+                                                         {"read_ndjson_objects", "json"},
+                                                         {"read_parquet", "parquet"},
+                                                         {"row_to_json", "json"},
+                                                         {"scan_arrow_ipc", "arrow"},
+                                                         {"sqlite_attach", "sqlite_scanner"},
+                                                         {"sqlite_scan", "sqlite_scanner"},
+                                                         {"stem", "fts"},
+                                                         {"text", "excel"},
+                                                         {"to_arrow_ipc", "arrow"},
+                                                         {"to_json", "json"},
+                                                         {"tpcds", "tpcds"},
+                                                         {"tpcds_answers", "tpcds"},
+                                                         {"tpcds_queries", "tpcds"},
+                                                         {"tpch", "tpch"},
+                                                         {"tpch_answers", "tpch"},
+                                                         {"tpch_queries", "tpch"},
+                                                         {"visualize_diff_profiling_output", "visualizer"},
+                                                         {"visualize_json_profiling_output", "visualizer"},
+                                                         {"visualize_last_profiling_output", "visualizer"},
+                                                         {"st_distance_spheroid", "spatial"},
+                                                         {"st_boundary", "spatial"},
+                                                         {"st_makeline", "spatial"},
+                                                         {"st_buffer", "spatial"},
+                                                         {"st_x", "spatial"},
+                                                         {"st_isring", "spatial"},
+                                                         {"st_centroid", "spatial"},
+                                                         {"st_read", "spatial"},
+                                                         {"st_geomfromwkb", "spatial"},
+                                                         {"st_list_proj_crs", "spatial"},
+                                                         {"st_isvalid", "spatial"},
+                                                         {"st_polygon2dfromwkb", "spatial"},
+                                                         {"st_disjoint", "spatial"},
+                                                         {"st_length", "spatial"},
+                                                         {"st_difference", "spatial"},
+                                                         {"st_area", "spatial"},
+                                                         {"st_union", "spatial"},
+                                                         {"st_isclosed", "spatial"},
+                                                         {"st_asgeojson", "spatial"},
+                                                         {"st_intersection", "spatial"},
+                                                         {"st_transform", "spatial"},
+                                                         {"st_dwithin", "spatial"},
+                                                         {"st_perimeter", "spatial"},
+                                                         {"st_issimple", "spatial"},
+                                                         {"st_geometrytype", "spatial"},
+                                                         {"st_simplifypreservetopology", "spatial"},
+                                                         {"st_distance", "spatial"},
+                                                         {"st_astext", "spatial"},
+                                                         {"st_overlaps", "spatial"},
+                                                         {"st_convexhull", "spatial"},
+                                                         {"st_normalize", "spatial"},
+                                                         {"st_drivers", "spatial"},
+                                                         {"st_point2dfromwkb", "spatial"},
+                                                         {"st_point2d", "spatial"},
+                                                         {"st_y", "spatial"},
+                                                         {"st_dwithin_spheroid", "spatial"},
+                                                         {"st_isempty", "spatial"},
+                                                         {"st_simplify", "spatial"},
+                                                         {"st_area_spheroid", "spatial"},
+                                                         {"st_within", "spatial"},
+                                                         {"st_length_spheroid", "spatial"},
+                                                         {"st_point3d", "spatial"},
+                                                         {"st_containsproperly", "spatial"},
+                                                         {"st_contains", "spatial"},
+                                                         {"st_collect", "spatial"},
+                                                         {"st_touches", "spatial"},
+                                                         {"st_linestring2dfromwkb", "spatial"},
+                                                         {"st_flipcoordinates", "spatial"},
+                                                         {"st_ashexwkb", "spatial"},
+                                                         {"st_geomfromtext", "spatial"},
+                                                         {"st_point4d", "spatial"},
+                                                         {"st_point", "spatial"},
+                                                         {"st_coveredby", "spatial"},
+                                                         {"st_perimeter_spheroid", "spatial"},
+                                                         {"st_intersects", "spatial"},
+                                                         {"st_crosses", "spatial"},
+                                                         {"st_covers", "spatial"},
+                                                         {"st_envelope", "spatial"},
+                                                         {"st_aswkb", "spatial"},
+                                                         {"st_equals", "spatial"},
+                                                         {"st_collectionextract", "spatial"},
+                                                         {"st_npoints", "spatial"},
+                                                         {"st_pointonsurface", "spatial"},
+                                                         {"st_dimension", "spatial"},
+                                                         {"st_removerepeatedpoints", "spatial"},
+                                                         {"st_geomfromgeojson", "spatial"},
+                                                         {"st_readosm", "spatial"},
+                                                         {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"binary_as_string", "parquet"},

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/common/arrow/arrow_options.hpp"
 
 namespace duckdb {
 struct BoxRendererConfig;
@@ -20,7 +21,11 @@ enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDI
 
 //! A set of properties from the client context that can be used to interpret the query result
 struct ClientProperties {
+	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
+	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
+	}
 	string time_zone;
+	ArrowOffsetSize arrow_offset_size;
 };
 
 class BaseQueryResult {
@@ -89,6 +94,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;
@@ -124,6 +146,7 @@ public:
 		}
 	}
 
+	static ArrowOptions GetArrowOptions(QueryResult &query_result);
 	static string GetConfigTimezone(QueryResult &query_result);
 
 private:

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 =
@@ -388,6 +397,16 @@ struct PreserveInsertionOrder {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct ExportLargeBufferArrow {
+	static constexpr const char *Name = "arrow_large_buffer_size";
+	static constexpr const char *Description =
+	    "If arrow buffers for strings, blobs, uuids and bits should be exported using large buffers";
+	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 ProfilerHistorySize {
 	static constexpr const char *Name = "profiler_history_size";
 	static constexpr const char *Description = "Sets the profiler history size";

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/optimizer/unnest_rewriter.hpp

@@ -45,6 +45,8 @@ public:
 
 	//! Contains all bindings that need to be updated
 	vector<ReplaceBinding> replace_bindings;
+	//! Stores the table index of the former child of the LOGICAL_UNNEST
+	idx_t overwritten_tbl_idx;
 };
 
 //! The UnnestRewriter optimizer traverses the logical operator tree and rewrites duplicate
@@ -79,6 +81,8 @@ private:
 	vector<LHSBinding> lhs_bindings;
 	//! Stores the table index of the former child of the LOGICAL_UNNEST
 	idx_t overwritten_tbl_idx;
+	//! The number of distinct columns to unnest
+	idx_t distinct_unnest_count;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp

@@ -14,6 +14,13 @@ namespace duckdb {
 
 class PhysicalRecursiveCTE;
 
+struct PipelineFinishGroup {
+	explicit PipelineFinishGroup(Pipeline *group_base_p) : group_base(group_base_p) {
+	}
+	Pipeline *group_base;
+	unordered_set<Pipeline *> group_members;
+};
+
 //! MetaPipeline represents a set of pipelines that all have the same sink
 class MetaPipeline : public std::enable_shared_from_this<MetaPipeline> {
 	//! We follow these rules when building:
@@ -57,7 +64,9 @@ public:
 	//! Make sure that the given pipeline has its own PipelineFinishEvent (e.g., for IEJoin - double Finalize)
 	void AddFinishEvent(Pipeline *pipeline);
 	//! Whether the pipeline needs its own PipelineFinishEvent
-	bool HasFinishEvent(Pipeline *pipeline);
+	bool HasFinishEvent(Pipeline *pipeline) const;
+	//! Whether this pipeline is part of a PipelineFinishEvent
+	optional_ptr<Pipeline> GetFinishGroup(Pipeline *pipeline) const;
 
 public:
 	//! Build the MetaPipeline with 'op' as the first operator (excl. the shared sink)
@@ -86,8 +95,6 @@ private:
 	bool recursive_cte;
 	//! All pipelines with a different source, but the same sink
 	vector<shared_ptr<Pipeline>> pipelines;
-	//! The pipelines that must finish before the MetaPipeline is finished
-	vector<Pipeline *> final_pipelines;
 	//! Dependencies within this MetaPipeline
 	unordered_map<Pipeline *, vector<Pipeline *>> dependencies;
 	//! Other MetaPipelines that this MetaPipeline depends on
@@ -96,6 +103,8 @@ private:
 	idx_t next_batch_index;
 	//! Pipelines (other than the base pipeline) that need their own PipelineFinishEvent (e.g., for IEJoin)
 	unordered_set<Pipeline *> finish_pipelines;
+	//! Mapping from pipeline (e.g., child or union) to finish pipeline
+	unordered_map<Pipeline *, Pipeline *> finish_map;
 };
 
 } // namespace duckdb

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;
 

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

@@ -41,7 +41,7 @@ public:
 	string GetName() const override;
 	string ToString() const override;
 
-	static bool Equal(const ColumnRefExpression *a, const ColumnRefExpression *b);
+	static bool Equal(const ColumnRefExpression &a, const ColumnRefExpression &b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;