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

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_count.hpp

@@ -16,26 +16,25 @@ namespace duckdb {
 
 struct RegrCountFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		*state = 0;
+	static void Initialize(STATE &state) {
+		state = 0;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		*target += source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target += source;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		target[idx] = *state;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		target = state;
 	}
 	static bool IgnoreNull() {
 		return true;
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		*state += 1;
+	static void Operation(STATE &state, const A_TYPE &, const B_TYPE &, AggregateBinaryInput &) {
+		state += 1;
 	}
 };
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_slope.hpp

@@ -19,40 +19,38 @@ struct RegrSlopeState {
 
 struct RegrSlopeOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
+	static void Initialize(STATE &state) {
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, y_data, x_data,
-		                                                          bmask, amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->cov_pop.count == 0 || state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.cov_pop.count == 0 || state.var_pop.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
-			auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
+			auto cov = state.cov_pop.co_moment / state.cov_pop.count;
+			auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
 			if (!Value::DoubleIsFinite(var_pop)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 			if (var_pop == 0) {
-				mask.SetInvalid(idx);
+				finalize_data.ReturnNull();
 				return;
 			}
-			target[idx] = cov / var_pop;
+			target = cov / var_pop;
 		}
 	}
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/sum_helpers.hpp

@@ -133,27 +133,26 @@ struct HugeintAdd {
 template <class STATEOP, class ADDOP>
 struct BaseSumOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = 0;
+	static void Initialize(STATE &state) {
+		state.value = 0;
 		STATEOP::template Initialize<STATE>(state);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
 		STATEOP::template Combine<STATE>(source, target, aggr_input_data);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
 		STATEOP::template AddValues<STATE>(state, 1);
-		ADDOP::template AddNumber<STATE, INPUT_TYPE>(*state, input[idx]);
+		ADDOP::template AddNumber<STATE, INPUT_TYPE>(state, input);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &, idx_t count) {
 		STATEOP::template AddValues<STATE>(state, count);
-		ADDOP::template AddConstant<STATE, INPUT_TYPE>(*state, *input, count);
+		ADDOP::template AddConstant<STATE, INPUT_TYPE>(state, input, count);
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/include/duckdb/core_functions/scalar/generic_functions.hpp

@@ -121,6 +121,15 @@ struct CurrentDatabaseFun {
 	static ScalarFunction GetFunction();
 };
 
+struct InSearchPathFun {
+	static constexpr const char *Name = "in_search_path";
+	static constexpr const char *Parameters = "database_name,schema_name";
+	static constexpr const char *Description = "Returns whether or not the database/schema are in the search path.";
+	static constexpr const char *Example = "in_search_path('memory', 'main')";
+
+	static ScalarFunction GetFunction();
+};
+
 struct CurrentTransactionIdFun {
 	static constexpr const char *Name = "txid_current";
 	static constexpr const char *Parameters = "";

package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp

@@ -43,10 +43,7 @@ struct MapEntriesFun {
 struct MapExtractFun {
 	static constexpr const char *Name = "map_extract";
 	static constexpr const char *Parameters = "map,key";
-	static constexpr const char *Description =
-	    "Return a list containing the value for a given key or an empty list if the key is not contained in the map. "
-	    "The type of the key provided in the second parameter must match the type of the map’s keys else an error is "
-	    "returned.";
+	static constexpr const char *Description = "Return a list containing the value for a given key or an empty list if the key is not contained in the map. The type of the key provided in the second parameter must match the type of the map’s keys else an error is returned.";
 	static constexpr const char *Example = "map_extract(map(['key'], ['val']), 'key')";
 
 	static ScalarFunction GetFunction();
@@ -70,8 +67,7 @@ struct MapFromEntriesFun {
 struct MapConcatFun {
 	static constexpr const char *Name = "map_concat";
 	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision "
-	                                           "the value is taken from the last map with that key";
+	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision the value is taken from the last map with that key";
 	static constexpr const char *Example = "map_concat(map([1,2], ['a', 'b']), map([2,3], ['c', 'd']));";
 
 	static ScalarFunction GetFunction();

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

@@ -31,8 +31,7 @@ struct StartsWithFun {
 struct ASCIIFun {
 	static constexpr const char *Name = "ascii";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description =
-	    "Returns an integer that represents the Unicode code point of the first character of the string.";
+	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string.";
 	static constexpr const char *Example = "ascii('Ω')";
 
 	static ScalarFunction GetFunction();
@@ -41,8 +40,7 @@ struct ASCIIFun {
 struct BarFun {
 	static constexpr const char *Name = "bar";
 	static constexpr const char *Parameters = "x,min,max,width";
-	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to "
-	                                           "width characters when x = max. width defaults to 80.";
+	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80.";
 	static constexpr const char *Example = "bar(5, 0, 20, 10)";
 
 	static ScalarFunctionSet GetFunctions();
@@ -66,8 +64,7 @@ struct ToBinaryFun {
 struct ChrFun {
 	static constexpr const char *Name = "chr";
 	static constexpr const char *Parameters = "code_point";
-	static constexpr const char *Description =
-	    "returns a character which is corresponding the ASCII code value or Unicode code point";
+	static constexpr const char *Description = "returns a character which is corresponding the ASCII code value or Unicode code point";
 	static constexpr const char *Example = "chr(65)";
 
 	static ScalarFunction GetFunction();
@@ -76,10 +73,7 @@ struct ChrFun {
 struct DamerauLevenshteinFun {
 	static constexpr const char *Name = "damerau_levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit "
-	    "operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or "
-	    "transpositions) required to change one string to another. Different case is considered different.";
+	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different.";
 	static constexpr const char *Example = "damerau_levenshtein('hello', 'world')";
 
 	static ScalarFunction GetFunction();
@@ -112,8 +106,7 @@ struct FormatreadabledecimalsizeFun {
 struct HammingFun {
 	static constexpr const char *Name = "hamming";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The number of positions with different characters for 2 strings of "
-	                                           "equal length. Different case is considered different.";
+	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different.";
 	static constexpr const char *Example = "hamming('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -143,8 +136,7 @@ struct ToHexFun {
 struct InstrFun {
 	static constexpr const char *Name = "instr";
 	static constexpr const char *Parameters = "haystack,needle";
-	static constexpr const char *Description =
-	    "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
+	static constexpr const char *Description = "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
 	static constexpr const char *Example = "instr('test test','es')";
 
 	static ScalarFunction GetFunction();
@@ -165,8 +157,7 @@ struct PositionFun {
 struct JaccardFun {
 	static constexpr const char *Name = "jaccard";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaccard('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -175,8 +166,7 @@ struct JaccardFun {
 struct JaroSimilarityFun {
 	static constexpr const char *Name = "jaro_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered "
-	                                           "different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -185,8 +175,7 @@ struct JaroSimilarityFun {
 struct JaroWinklerSimilarityFun {
 	static constexpr const char *Name = "jaro_winkler_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_winkler_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -213,9 +202,7 @@ struct LeftGraphemeFun {
 struct LevenshteinFun {
 	static constexpr const char *Name = "levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one "
-	    "string to the other. Different case is considered different.";
+	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different.";
 	static constexpr const char *Example = "levenshtein('duck','db')";
 
 	static ScalarFunction GetFunction();
@@ -230,8 +217,7 @@ struct Editdist3Fun {
 struct LpadFun {
 	static constexpr const char *Name = "lpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the left until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the left until it has count characters";
 	static constexpr const char *Example = "lpad('hello', 10, '>')";
 
 	static ScalarFunction GetFunction();
@@ -240,8 +226,7 @@ struct LpadFun {
 struct LtrimFun {
 	static constexpr const char *Name = "ltrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the left side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the left side of the string";
 	static constexpr const char *Example = "ltrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -340,8 +325,7 @@ struct RightGraphemeFun {
 struct RpadFun {
 	static constexpr const char *Name = "rpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the right until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the right until it has count characters";
 	static constexpr const char *Example = "rpad('hello', 10, '<')";
 
 	static ScalarFunction GetFunction();
@@ -350,8 +334,7 @@ struct RpadFun {
 struct RtrimFun {
 	static constexpr const char *Name = "rtrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the right side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the right side of the string";
 	static constexpr const char *Example = "rtrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -408,9 +391,7 @@ struct RegexpSplitToArrayFun {
 struct TranslateFun {
 	static constexpr const char *Name = "translate";
 	static constexpr const char *Parameters = "string,from,to";
-	static constexpr const char *Description =
-	    "Replaces each character in string that matches a character in the from set with the corresponding character "
-	    "in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
+	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
 	static constexpr const char *Example = "translate('12345', '143', 'ax')";
 
 	static ScalarFunction GetFunction();
@@ -419,8 +400,7 @@ struct TranslateFun {
 struct TrimFun {
 	static constexpr const char *Name = "trim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from either side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from either side of the string";
 	static constexpr const char *Example = "trim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -39,6 +39,18 @@ public:
 	DUCKDB_API ClientContext &GetContext();
 
 	void Verify(ExpressionExecutorState &root);
+
+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);
+	}
 };
 
 struct ExecuteFunctionState : public ExpressionState {
@@ -48,8 +60,8 @@ struct ExecuteFunctionState : public ExpressionState {
 	unique_ptr<FunctionLocalState> local_state;
 
 public:
-	static FunctionLocalState *GetFunctionState(ExpressionState &state) {
-		return ((ExecuteFunctionState &)state).local_state.get();
+	static optional_ptr<FunctionLocalState> GetFunctionState(ExpressionState &state) {
+		return state.Cast<ExecuteFunctionState>().local_state.get();
 	}
 };
 

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -110,13 +110,13 @@ private:
 	//! Find the node with a matching key, or return nullptr if not found
 	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 	//! Returns all row IDs belonging to a key greater (or equal) than the search key
-	bool SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, idx_t max_count,
+	bool SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
 	                   vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key less (or equal) than the upper_bound
-	bool SearchLess(ARTIndexScanState *state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
+	bool SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
 	                vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key within the range of lower_bound and upper_bound
-	bool SearchCloseRange(ARTIndexScanState *state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
+	bool SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
 	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
 
 	//! Initializes a merge operation by returning a set containing the buffer count of each fixed-size allocator

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp

@@ -16,6 +16,9 @@ class PreparedStatementData;
 
 //! PhysicalResultCollector is an abstract class that is used to generate the final result of a query
 class PhysicalResultCollector : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RESULT_COLLECTOR;
+
 public:
 	explicit PhysicalResultCollector(PreparedStatementData &data);
 

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

@@ -50,7 +50,7 @@ public:
 	BufferHandle AllocateBuffer(idx_t buffer_size);
 
 	char *Ptr() {
-		return (char *)handle.Ptr();
+		return char_ptr_cast(handle.Ptr());
 	}
 
 private:

package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp

@@ -30,6 +30,9 @@ class MetaPipeline;
 //! PhysicalOperator is the base class of the physical operators present in the
 //! execution plan
 class PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
+
 public:
 	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
 	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
@@ -184,7 +187,7 @@ public:
 		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -192,7 +195,7 @@ public:
 		if (TARGET::TYPE != PhysicalOperatorType::INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast physical operator to type - physical operator type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp

@@ -48,12 +48,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);
 	}
 };
 
@@ -65,12 +65,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);
 	}
 };
 
@@ -86,12 +86,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);
 	}
 };
 
@@ -106,12 +106,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);
 	}
 };
 
@@ -127,12 +127,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);
 	}
 };
 
@@ -144,12 +144,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);
 	}
 };
 

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

@@ -8,40 +8,13 @@
 
 #pragma once
 
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
+#include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.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(FunctionData *bind_data_p, Allocator &allocator_p)
-	    : bind_data(bind_data_p), allocator(allocator_p) {
-	}
-	FunctionData *bind_data;
-	Allocator &allocator;
-};
-
-struct AggregateStatisticsInput {
-	AggregateStatisticsInput(FunctionData *bind_data_p, vector<BaseStatistics> &child_stats_p,
-	                         NodeStatistics *node_stats_p)
-	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
-	}
-
-	FunctionData *bind_data;
-	vector<BaseStatistics> &child_stats;
-	NodeStatistics *node_stats;
-};
-
 //! The type used for sizing hashed aggregate function states
 typedef idx_t (*aggregate_size_t)();
 //! The type used for initializing hashed aggregate function states
@@ -215,7 +188,7 @@ public:
 
 	template <class STATE, class OP>
 	static void StateInitialize(data_ptr_t state) {
-		OP::Initialize((STATE *)state);
+		OP::Initialize(*reinterpret_cast<STATE *>(state));
 	}
 
 	template <class STATE, class OP>
@@ -281,6 +254,12 @@ public:
 		AggregateExecutor::Finalize<STATE, RESULT_TYPE, OP>(states, aggr_input_data, result, count, offset);
 	}
 
+	template <class STATE, class OP>
+	static void StateVoidFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+	                              idx_t offset) {
+		AggregateExecutor::VoidFinalize<STATE, OP>(states, aggr_input_data, result, count, offset);
+	}
+
 	template <class STATE, class OP>
 	static void StateDestroy(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
 		AggregateExecutor::Destroy<STATE, OP>(states, aggr_input_data, count);