duckdb 0.8.1-dev96.0 → 0.8.1

package/src/duckdb/src/common/types/time.cpp

@@ -194,9 +194,7 @@ dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t mic
 	return dtime_t(result);
 }
 
-// LCOV_EXCL_START
-#ifdef DEBUG
-static bool AssertValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
+bool Time::IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
 	if (hour < 0 || hour >= 24) {
 		return false;
 	}
@@ -211,8 +209,6 @@ static bool AssertValidTime(int32_t hour, int32_t minute, int32_t second, int32_
 	}
 	return true;
 }
-#endif
-// LCOV_EXCL_STOP
 
 void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int32_t &micros) {
 	int64_t time = dtime.micros;
@@ -223,9 +219,7 @@ void Time::Convert(dtime_t dtime, int32_t &hour, int32_t &min, int32_t &sec, int
 	sec = int32_t(time / Interval::MICROS_PER_SEC);
 	time -= int64_t(sec) * Interval::MICROS_PER_SEC;
 	micros = int32_t(time);
-#ifdef DEBUG
-	D_ASSERT(AssertValidTime(hour, min, sec, micros));
-#endif
+	D_ASSERT(Time::IsValidTime(hour, min, sec, micros));
 }
 
 dtime_t Time::FromTimeMs(int64_t time_ms) {

package/src/duckdb/src/common/types/timestamp.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/common/chrono.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/limits.hpp"
 #include <ctime>
 
@@ -21,6 +22,38 @@ static_assert(sizeof(timestamp_t) == sizeof(int64_t), "timestamp_t was padded");
 // Z is optional
 // ISO 8601
 
+// arithmetic operators
+timestamp_t timestamp_t::operator+(const double &value) const {
+	timestamp_t result;
+	if (!TryAddOperator::Operation(this->value, int64_t(value), result.value)) {
+		throw OutOfRangeException("Overflow in timestamp addition");
+	}
+	return result;
+}
+
+int64_t timestamp_t::operator-(const timestamp_t &other) const {
+	int64_t result;
+	if (!TrySubtractOperator::Operation(value, int64_t(other.value), result)) {
+		throw OutOfRangeException("Overflow in timestamp subtraction");
+	}
+	return result;
+}
+
+// in-place operators
+timestamp_t &timestamp_t::operator+=(const int64_t &delta) {
+	if (!TryAddOperator::Operation(value, delta, value)) {
+		throw OutOfRangeException("Overflow in timestamp increment");
+	}
+	return *this;
+}
+
+timestamp_t &timestamp_t::operator-=(const int64_t &delta) {
+	if (!TrySubtractOperator::Operation(value, delta, value)) {
+		throw OutOfRangeException("Overflow in timestamp decrement");
+	}
+	return *this;
+}
+
 bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset, string_t &tz) {
 	idx_t pos;
 	date_t date;
@@ -59,7 +92,10 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r
 			pos++;
 			has_offset = true;
 		} else if (Timestamp::TryParseUTCOffset(str, pos, len, hour_offset, minute_offset)) {
-			result -= hour_offset * Interval::MICROS_PER_HOUR + minute_offset * Interval::MICROS_PER_MINUTE;
+			const int64_t delta = hour_offset * Interval::MICROS_PER_HOUR + minute_offset * Interval::MICROS_PER_MINUTE;
+			if (!TrySubtractOperator::Operation(result.value, delta, result.value)) {
+				return false;
+			}
 			has_offset = true;
 		} else {
 			// Parse a time zone: / [A-Za-z0-9/_]+/

package/src/duckdb/src/common/types/value.cpp

@@ -1319,6 +1319,7 @@ string Value::ToSQLString() const {
 	case LogicalTypeId::BLOB:
 		return "'" + ToString() + "'::" + type_.ToString();
 	case LogicalTypeId::VARCHAR:
+	case LogicalTypeId::ENUM:
 		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
 	case LogicalTypeId::STRUCT: {
 		string ret = "{";

package/src/duckdb/src/common/types.cpp

@@ -559,6 +559,10 @@ bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
 		scale = DecimalType::GetScale(*this);
 		break;
 	default:
+		// Nonsense values to ensure initialization
+		width = 255u;
+		scale = 255u;
+		// FIXME(carlo): This should be probably a throw, requires checkign the various call-sites
 		return false;
 	}
 	return true;

package/src/duckdb/src/core_functions/aggregate/algebraic/avg.cpp

@@ -59,21 +59,21 @@ public:
 
 struct AverageSetOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
+	static void Initialize(STATE &state) {
+		state.Initialize();
 	}
 	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->Combine(source);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target.Combine(source);
 	}
 	template <class STATE>
-	static void AddValues(STATE *state, idx_t count) {
-		state->count += count;
+	static void AddValues(STATE &state, idx_t count) {
+		state.count += count;
 	}
 };
 
 template <class T>
-static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
+static T GetAverageDivident(uint64_t count, optional_ptr<FunctionData> bind_data) {
 	T divident = T(count);
 	if (bind_data) {
 		auto &avg_bind_data = bind_data->Cast<AverageDecimalBindData>();
@@ -84,61 +84,58 @@ static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
 
 struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			double divident = GetAverageDivident<double>(state->count, aggr_input_data.bind_data);
-			target[idx] = double(state->value) / divident;
+			double divident = GetAverageDivident<double>(state.count, finalize_data.input.bind_data);
+			target = double(state.value) / divident;
 		}
 	}
 };
 
 struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
+			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
+			target = Hugeint::Cast<long double>(state.value) / divident;
 		}
 	}
 };
 
 struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
+			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
+			target = Hugeint::Cast<long double>(state.value) / divident;
 		}
 	}
 };
 
 struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = (state->value / state->count);
+			target = state.value / state.count;
 		}
 	}
 };
 
 struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, KahanAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = (state->value / state->count) + (state->err / state->count);
+			target = (state.value / state.count) + (state.err / state.count);
 		}
 	}
 };

package/src/duckdb/src/core_functions/aggregate/algebraic/covar.cpp

@@ -1,10 +1,6 @@
 #include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/function_set.hpp"
 #include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
-#include <cmath>
 
 namespace duckdb {
 

package/src/duckdb/src/core_functions/aggregate/distributive/approx_count.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/hyperloglog.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 
@@ -16,52 +15,50 @@ struct ApproxDistinctCountState {
 			delete log;
 		}
 	}
-	void Resize(idx_t count) {
-		indices.resize(count);
-		counts.resize(count);
-	}
 
 	HyperLogLog *log;
-	vector<uint64_t> indices;
-	vector<uint8_t> counts;
 };
 
 struct ApproxCountDistinctFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE;
+	static void Initialize(STATE &state) {
+		state.log = nullptr;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.log) {
 			return;
 		}
-		if (!target->log) {
-			target->log = new HyperLogLog();
+		if (!target.log) {
+			target.log = new HyperLogLog();
 		}
-		D_ASSERT(target->log);
+		D_ASSERT(target.log);
 		D_ASSERT(source.log);
-		auto new_log = target->log->MergePointer(*source.log);
-		delete target->log;
-		target->log = new_log;
+		auto new_log = target.log->MergePointer(*source.log);
+		delete target.log;
+		target.log = new_log;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->log) {
-			target[idx] = state->log->Count();
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.log) {
+			target = state.log->Count();
 		} else {
-			target[idx] = 0;
+			target = 0;
 		}
 	}
 
 	static bool IgnoreNull() {
 		return true;
 	}
+
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->~STATE();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.log) {
+			delete state.log;
+			state.log = nullptr;
+		}
 	}
 };
 
@@ -77,10 +74,11 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
 	UnifiedVectorFormat vdata;
 	inputs[0].ToUnifiedFormat(count, vdata);
 
-	agg_state->Resize(count);
-	auto indices = agg_state->indices.data();
-	auto counts = agg_state->counts.data();
-
+	if (count > STANDARD_VECTOR_SIZE) {
+		throw InternalException("ApproxCountDistinct - count must be at most vector size");
+	}
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
 	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
 	agg_state->log->AddToLog(vdata, count, indices, counts);
 }
@@ -93,23 +91,21 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = UnifiedVectorFormat::GetDataNoConst<ApproxDistinctCountState *>(sdata);
 
-	uint64_t *indices = nullptr;
-	uint8_t *counts = nullptr;
 	for (idx_t i = 0; i < count; i++) {
 		auto agg_state = states[sdata.sel->get_index(i)];
 		if (!agg_state->log) {
 			agg_state->log = new HyperLogLog();
 		}
-		if (i == 0) {
-			agg_state->Resize(count);
-			indices = agg_state->indices.data();
-			counts = agg_state->counts.data();
-		}
 	}
 
 	UnifiedVectorFormat vdata;
 	inputs[0].ToUnifiedFormat(count, vdata);
 
+	if (count > STANDARD_VECTOR_SIZE) {
+		throw InternalException("ApproxCountDistinct - count must be at most vector size");
+	}
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
 	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
 	HyperLogLog::AddToLogs(vdata, count, indices, counts, reinterpret_cast<HyperLogLog ***>(states), sdata.sel);
 }
@@ -142,6 +138,7 @@ AggregateFunctionSet ApproxCountDistinctFun::GetFunctions() {
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::VARCHAR));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP_TZ));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::BLOB));
 	return approx_count;
 }
 

package/src/duckdb/src/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -25,8 +25,8 @@ struct ArgMinMaxStateBase {
 	}
 
 	template <typename T>
-	static inline void ReadValue(Vector &result, T &arg, T *target, idx_t idx) {
-		target[idx] = arg;
+	static inline void ReadValue(Vector &result, T &arg, T &target) {
+		target = arg;
 	}
 
 	bool is_initialized;
@@ -69,8 +69,8 @@ void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, bool
 }
 
 template <>
-void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t *target, idx_t idx) {
-	target[idx] = StringVector::AddStringOrBlob(result, arg);
+void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t &target) {
+	target = StringVector::AddStringOrBlob(result, arg);
 }
 
 template <class A, class B>
@@ -97,54 +97,54 @@ struct ArgMinMaxState : public ArgMinMaxStateBase {
 
 template <class COMPARATOR>
 struct ArgMinMaxBase {
+
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->~STATE();
+	static void Initialize(STATE &state) {
+		new (&state) STATE;
 	}
 
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		state.~STATE();
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		if (!state->is_initialized) {
-			STATE::template AssignValue<A_TYPE>(state->arg, x_data[xidx], false);
-			STATE::template AssignValue<B_TYPE>(state->value, y_data[yidx], false);
-			state->is_initialized = true;
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &) {
+		if (!state.is_initialized) {
+			STATE::template AssignValue<A_TYPE>(state.arg, x, false);
+			STATE::template AssignValue<B_TYPE>(state.value, y, false);
+			state.is_initialized = true;
 		} else {
-			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x_data[xidx], y_data[yidx]);
+			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x, y);
 		}
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Execute(STATE *state, A_TYPE x_data, B_TYPE y_data) {
-		if (COMPARATOR::Operation(y_data, state->value)) {
-			STATE::template AssignValue<A_TYPE>(state->arg, x_data, true);
-			STATE::template AssignValue<B_TYPE>(state->value, y_data, true);
+	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data) {
+		if (COMPARATOR::Operation(y_data, state.value)) {
+			STATE::template AssignValue<A_TYPE>(state.arg, x_data, true);
+			STATE::template AssignValue<B_TYPE>(state.value, y_data, true);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.is_initialized) {
 			return;
 		}
-		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			STATE::template AssignValue(target->arg, source.arg, target->is_initialized);
-			STATE::template AssignValue(target->value, source.value, target->is_initialized);
-			target->is_initialized = true;
+		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
+			STATE::template AssignValue(target.arg, source.arg, target.is_initialized);
+			STATE::template AssignValue(target.value, source.value, target.is_initialized);
+			target.is_initialized = true;
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_initialized) {
+			finalize_data.ReturnNull();
 		} else {
-			STATE::template ReadValue(result, state->arg, target, idx);
+			STATE::template ReadValue(finalize_data.result, state.arg, target);
 		}
 	}
 
@@ -156,14 +156,14 @@ struct ArgMinMaxBase {
 template <typename COMPARATOR>
 struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 	template <class STATE>
-	static void AssignVector(STATE *state, Vector &arg, const idx_t idx) {
-		if (!state->is_initialized) {
-			state->arg = new Vector(arg.GetType());
-			state->arg->SetVectorType(VectorType::CONSTANT_VECTOR);
+	static void AssignVector(STATE &state, Vector &arg, const idx_t idx) {
+		if (!state.is_initialized) {
+			state.arg = new Vector(arg.GetType());
+			state.arg->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
 		sel_t selv = idx;
 		SelectionVector sel(&selv);
-		VectorOperations::Copy(arg, *state->arg, sel, 1, 0, 0);
+		VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0);
 	}
 
 	template <class STATE>
@@ -190,49 +190,37 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 			const auto bval = bys[bidx];
 
 			const auto sidx = sdata.sel->get_index(i);
-			auto state = states[sidx];
-			if (!state->is_initialized) {
-				STATE::template AssignValue<BY_TYPE>(state->value, bval, false);
+			auto &state = *states[sidx];
+			if (!state.is_initialized) {
+				STATE::template AssignValue<BY_TYPE>(state.value, bval, false);
 				AssignVector(state, arg, i);
-				state->is_initialized = true;
+				state.is_initialized = true;
 
-			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state->value)) {
-				STATE::template AssignValue<BY_TYPE>(state->value, bval, true);
+			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state.value)) {
+				STATE::template AssignValue<BY_TYPE>(state.value, bval, true);
 				AssignVector(state, arg, i);
 			}
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.is_initialized) {
 			return;
 		}
-		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			STATE::template AssignValue(target->value, source.value, target->is_initialized);
+		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
+			STATE::template AssignValue(target.value, source.value, target.is_initialized);
 			AssignVector(target, *source.arg, 0);
-			target->is_initialized = true;
+			target.is_initialized = true;
 		}
 	}
 
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			// we need to use SetNull here
-			// since for STRUCT columns only setting the validity mask of the struct is incorrect
-			// as for a struct column, we need to also set ALL child columns to NULL
-			switch (result.GetVectorType()) {
-			case VectorType::FLAT_VECTOR:
-				FlatVector::SetNull(result, idx, true);
-				break;
-			case VectorType::CONSTANT_VECTOR:
-				ConstantVector::SetNull(result, true);
-				break;
-			default:
-				throw InternalException("Invalid result vector type for nested arg_min/max");
-			}
+	template <class STATE>
+	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
+		if (!state.is_initialized) {
+			finalize_data.ReturnNull();
 		} else {
-			VectorOperations::Copy(*state->arg, result, 1, 0, idx);
+			VectorOperations::Copy(*state.arg, finalize_data.result, 1, 0, finalize_data.result_idx);
 		}
 	}
 
@@ -247,11 +235,10 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 template <class OP, class ARG_TYPE, class BY_TYPE>
 AggregateFunction GetVectorArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
 	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	return AggregateFunction({type, by_type}, type, AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE>,
-	                         AggregateFunction::StateCombine<STATE, OP>,
-	                         AggregateFunction::StateFinalize<STATE, void, OP>, nullptr, OP::Bind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
+	return AggregateFunction(
+	    {type, by_type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
+	    OP::template Update<STATE>, AggregateFunction::StateCombine<STATE, OP>,
+	    AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind, AggregateFunction::StateDestroy<STATE, OP>);
 }
 
 template <class OP, class ARG_TYPE>