duckdb 0.8.1-dev65.0 → 0.8.1

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

@@ -97,8 +97,11 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
-	//! Returns the string representation of the ART
-	string ToString() override;
+	//! Returns the string representation of the ART, or only traverses and verifies the index
+	string VerifyAndToString(IndexLock &state, const bool only_verify) override;
+
+	//! Find the node with a matching key, or return nullptr if not found
+	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 
 private:
 	//! Insert a row ID into a leaf
@@ -107,16 +110,15 @@ private:
 	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
 	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
-	//! 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
@@ -129,6 +131,10 @@ private:
 	//! Finalizes a vacuum operation by calling the finalize operation of all qualifying
 	//! fixed size allocators
 	void FinalizeVacuum(const ARTFlags &flags);
+
+	//! Internal function to return the string representation of the ART,
+	//! or only traverses and verifies the index
+	string VerifyAndToStringInternal(const bool only_verify);
 };
 
 } // namespace duckdb

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

@@ -100,6 +100,9 @@ public:
 	//! Vacuums a pointer
 	SwizzleablePointer VacuumPointer(const SwizzleablePointer ptr);
 
+	//! Verify that the allocation counts match the existing positions on the buffers
+	void Verify() const;
+
 private:
 	//! Returns the data_ptr_t of a pointer
 	inline data_ptr_t Get(const SwizzleablePointer ptr) const {

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

@@ -73,7 +73,7 @@ public:
 	uint32_t FindRowId(const ART &art, Node &ptr, const row_t row_id) const;
 
 	//! Returns the string representation of a leaf
-	string ToString(const ART &art) const;
+	string VerifyAndToString(const ART &art, const bool only_verify) const;
 
 	//! Serialize this leaf
 	BlockPointer Serialize(const ART &art, MetaBlockWriter &writer) const;

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

@@ -26,6 +26,8 @@ public:
 	static inline LeafSegment &Get(const ART &art, const Node ptr) {
 		return *Node::GetAllocator(art, NType::LEAF_SEGMENT).Get<LeafSegment>(ptr);
 	}
+	//! Free the leaf segment and any subsequent ones
+	static void Free(ART &art, Node &node);
 
 	//! Append a row ID to the current segment, or create a new segment containing that row ID
 	LeafSegment &Append(ART &art, uint32_t &count, const row_t row_id);

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

@@ -65,13 +65,23 @@ public:
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
 
+	inline bool operator==(const Node &node) const {
+		return swizzle_flag == node.swizzle_flag && type == node.type && offset == node.offset &&
+		       buffer_id == node.buffer_id;
+	}
+
 	//! Retrieve the node type from the leftmost byte
 	inline NType DecodeARTNodeType() const {
+		D_ASSERT(!IsSwizzled());
+		D_ASSERT(type >= (uint8_t)NType::PREFIX_SEGMENT);
+		D_ASSERT(type <= (uint8_t)NType::NODE_256);
 		return NType(type);
 	}
 
 	//! Set the pointer
 	inline void SetPtr(const SwizzleablePointer ptr) {
+		swizzle_flag = ptr.swizzle_flag;
+		type = ptr.type;
 		offset = ptr.offset;
 		buffer_id = ptr.buffer_id;
 	}
@@ -86,15 +96,15 @@ public:
 	//! Get the child for the respective byte in the node
 	optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte) const;
+	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte, const bool deserialize = true) const;
 
 	//! Serialize the node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize the node
 	void Deserialize(ART &art);
 
-	//! Returns the string representation of the node
-	string ToString(ART &art) const;
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
+	string VerifyAndToString(ART &art, const bool only_verify);
 	//! Returns the capacity of the node
 	idx_t GetCapacity() const;
 	//! Returns a pointer to the prefix of the node

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

@@ -59,6 +59,7 @@ public:
 	//! Get the child for the respective byte in the node
 	inline optional_ptr<Node> GetChild(const uint8_t byte) {
 		if (child_index[byte] != Node::EMPTY_MARKER) {
+			D_ASSERT(children[child_index[byte]].IsSet());
 			return &children[child_index[byte]];
 		}
 		return nullptr;

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
@@ -76,7 +49,7 @@ typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_m
 
 typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
                                       const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(ClientContext &context, FieldReader &reader,
+typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                             AggregateFunction &function);
 
 class AggregateFunction : public BaseScalarFunction {
@@ -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);

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);
 	}
 };