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

package/src/duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp

@@ -70,7 +70,7 @@ struct BinaryLambdaWrapperWithNulls {
 struct BinaryExecutor {
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC,
 	          bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static void ExecuteFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	static void ExecuteFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                            RESULT_TYPE *__restrict result_data, idx_t count, ValidityMask &mask, FUNC fun) {
 		if (!LEFT_CONSTANT) {
 			ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
@@ -184,7 +184,7 @@ struct BinaryExecutor {
 	}
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
-	static void ExecuteGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	static void ExecuteGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                               RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
 	                               const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lvalidity,
 	                               ValidityMask &rvalidity, ValidityMask &result_validity, FUNC fun) {
@@ -221,8 +221,9 @@ struct BinaryExecutor {
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
 		ExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OPWRAPPER, OP, FUNC>(
-		    (LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data, result_data, ldata.sel, rdata.sel, count, ldata.validity,
-		    rdata.validity, FlatVector::Validity(result), fun);
+		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata),
+		    result_data, ldata.sel, rdata.sel, count, ldata.validity, rdata.validity, FlatVector::Validity(result),
+		    fun);
 	}
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP, class FUNC>
@@ -300,7 +301,7 @@ public:
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool HAS_TRUE_SEL,
 	          bool HAS_FALSE_SEL>
-	static inline idx_t SelectFlatLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	static inline idx_t SelectFlatLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                                   const SelectionVector *sel, idx_t count, ValidityMask &validity_mask,
 	                                   SelectionVector *true_sel, SelectionVector *false_sel) {
 		idx_t true_count = 0, false_count = 0;
@@ -364,7 +365,7 @@ public:
 	}
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
-	static inline idx_t SelectFlatLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	static inline idx_t SelectFlatLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                                         const SelectionVector *sel, idx_t count, ValidityMask &mask,
 	                                         SelectionVector *true_sel, SelectionVector *false_sel) {
 		if (true_sel && false_sel) {
@@ -419,10 +420,10 @@ public:
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
 	static inline idx_t
-	SelectGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata, const SelectionVector *__restrict lsel,
-	                  const SelectionVector *__restrict rsel, const SelectionVector *__restrict result_sel, idx_t count,
-	                  ValidityMask &lvalidity, ValidityMask &rvalidity, SelectionVector *true_sel,
-	                  SelectionVector *false_sel) {
+	SelectGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
+	                  const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
+	                  const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
+	                  ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
 		idx_t true_count = 0, false_count = 0;
 		for (idx_t i = 0; i < count; i++) {
 			auto result_idx = result_sel->get_index(i);
@@ -447,7 +448,7 @@ public:
 	}
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
 	static inline idx_t
-	SelectGenericLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	SelectGenericLoopSelSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                           const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
 	                           const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
 	                           ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
@@ -466,7 +467,7 @@ public:
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
 	static inline idx_t
-	SelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+	SelectGenericLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
 	                        const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
 	                        const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lvalidity,
 	                        ValidityMask &rvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
@@ -487,9 +488,9 @@ public:
 		left.ToUnifiedFormat(count, ldata);
 		right.ToUnifiedFormat(count, rdata);
 
-		return SelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>((LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data,
-		                                                          ldata.sel, rdata.sel, sel, count, ldata.validity,
-		                                                          rdata.validity, true_sel, false_sel);
+		return SelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>(
+		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata), ldata.sel,
+		    rdata.sel, sel, count, ldata.validity, rdata.validity, true_sel, false_sel);
 	}
 
 	template <class LEFT_TYPE, class RIGHT_TYPE, class OP>

package/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp

@@ -38,7 +38,7 @@ struct PrimitiveType {
 	static bool ConstructType(STRUCT_STATE &state, idx_t i, PrimitiveType<INPUT_TYPE> &result) {
 		auto &vdata = state.main_data;
 		auto idx = vdata.sel->get_index(i);
-		auto ptr = (INPUT_TYPE *)vdata.data;
+		auto ptr = UnifiedVectorFormat::GetData<INPUT_TYPE>(vdata);
 		result.val = ptr[idx];
 		return true;
 	}
@@ -77,7 +77,7 @@ struct StructTypeUnary {
 		if (!a_data.validity.RowIsValid(a_idx)) {
 			return false;
 		}
-		auto a_ptr = (A_TYPE *)a_data.data;
+		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
 		result.a_val = a_ptr[a_idx];
 		return true;
 	}
@@ -106,8 +106,8 @@ struct StructTypeBinary {
 		if (!a_data.validity.RowIsValid(a_idx) || !b_data.validity.RowIsValid(b_idx)) {
 			return false;
 		}
-		auto a_ptr = (A_TYPE *)a_data.data;
-		auto b_ptr = (B_TYPE *)b_data.data;
+		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
+		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
 		result.a_val = a_ptr[a_idx];
 		result.b_val = b_ptr[b_idx];
 		return true;
@@ -143,9 +143,9 @@ struct StructTypeTernary {
 		    !c_data.validity.RowIsValid(c_idx)) {
 			return false;
 		}
-		auto a_ptr = (A_TYPE *)a_data.data;
-		auto b_ptr = (B_TYPE *)b_data.data;
-		auto c_ptr = (C_TYPE *)c_data.data;
+		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
+		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
+		auto c_ptr = UnifiedVectorFormat::GetData<C_TYPE>(c_data);
 		result.a_val = a_ptr[a_idx];
 		result.b_val = b_ptr[b_idx];
 		result.c_val = c_ptr[c_idx];
@@ -188,10 +188,10 @@ struct StructTypeQuaternary {
 		    !c_data.validity.RowIsValid(c_idx) || !d_data.validity.RowIsValid(d_idx)) {
 			return false;
 		}
-		auto a_ptr = (A_TYPE *)a_data.data;
-		auto b_ptr = (B_TYPE *)b_data.data;
-		auto c_ptr = (C_TYPE *)c_data.data;
-		auto d_ptr = (D_TYPE *)d_data.data;
+		auto a_ptr = UnifiedVectorFormat::GetData<A_TYPE>(a_data);
+		auto b_ptr = UnifiedVectorFormat::GetData<B_TYPE>(b_data);
+		auto c_ptr = UnifiedVectorFormat::GetData<C_TYPE>(c_data);
+		auto d_ptr = UnifiedVectorFormat::GetData<D_TYPE>(d_data);
 		result.a_val = a_ptr[a_idx];
 		result.b_val = b_ptr[b_idx];
 		result.c_val = c_ptr[c_idx];

package/src/duckdb/src/include/duckdb/common/vector_operations/ternary_executor.hpp

@@ -41,11 +41,11 @@ struct TernaryLambdaWrapperWithNulls {
 struct TernaryExecutor {
 private:
 	template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OPWRAPPER, class FUN>
-	static inline void ExecuteLoop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
-	                               RESULT_TYPE *__restrict result_data, idx_t count, const SelectionVector &asel,
-	                               const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity,
-	                               ValidityMask &bvalidity, ValidityMask &cvalidity, ValidityMask &result_validity,
-	                               FUN fun) {
+	static inline void ExecuteLoop(const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata,
+	                               const C_TYPE *__restrict cdata, RESULT_TYPE *__restrict result_data, idx_t count,
+	                               const SelectionVector &asel, const SelectionVector &bsel,
+	                               const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity,
+	                               ValidityMask &cvalidity, ValidityMask &result_validity, FUN fun) {
 		if (!avalidity.AllValid() || !bvalidity.AllValid() || !cvalidity.AllValid()) {
 			for (idx_t i = 0; i < count; i++) {
 				auto aidx = asel.get_index(i);
@@ -95,9 +95,10 @@ public:
 			c.ToUnifiedFormat(count, cdata);
 
 			ExecuteLoop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OPWRAPPER>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data,
-			    FlatVector::GetData<RESULT_TYPE>(result), count, *adata.sel, *bdata.sel, *cdata.sel, adata.validity,
-			    bdata.validity, cdata.validity, FlatVector::Validity(result), fun);
+			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), FlatVector::GetData<RESULT_TYPE>(result), count,
+			    *adata.sel, *bdata.sel, *cdata.sel, adata.validity, bdata.validity, cdata.validity,
+			    FlatVector::Validity(result), fun);
 		}
 	}
 
@@ -122,11 +123,11 @@ public:
 
 private:
 	template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-	static inline idx_t SelectLoop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
-	                               const SelectionVector *result_sel, idx_t count, const SelectionVector &asel,
-	                               const SelectionVector &bsel, const SelectionVector &csel, ValidityMask &avalidity,
-	                               ValidityMask &bvalidity, ValidityMask &cvalidity, SelectionVector *true_sel,
-	                               SelectionVector *false_sel) {
+	static inline idx_t SelectLoop(const A_TYPE *__restrict adata, const B_TYPE *__restrict bdata,
+	                               const C_TYPE *__restrict cdata, const SelectionVector *result_sel, idx_t count,
+	                               const SelectionVector &asel, const SelectionVector &bsel,
+	                               const SelectionVector &csel, ValidityMask &avalidity, ValidityMask &bvalidity,
+	                               ValidityMask &cvalidity, SelectionVector *true_sel, SelectionVector *false_sel) {
 		idx_t true_count = 0, false_count = 0;
 		for (idx_t i = 0; i < count; i++) {
 			auto result_idx = result_sel->get_index(i);
@@ -158,17 +159,20 @@ private:
 	                                        SelectionVector *true_sel, SelectionVector *false_sel) {
 		if (true_sel && false_sel) {
 			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, true>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
+			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
+			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
 		} else if (true_sel) {
 			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, true, false>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
+			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
+			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
 		} else {
 			D_ASSERT(false_sel);
 			return SelectLoop<A_TYPE, B_TYPE, C_TYPE, OP, NO_NULL, false, true>(
-			    (A_TYPE *)adata.data, (B_TYPE *)bdata.data, (C_TYPE *)cdata.data, sel, count, *adata.sel, *bdata.sel,
-			    *cdata.sel, adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
+			    UnifiedVectorFormat::GetData<A_TYPE>(adata), UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+			    UnifiedVectorFormat::GetData<C_TYPE>(cdata), sel, count, *adata.sel, *bdata.sel, *cdata.sel,
+			    adata.validity, bdata.validity, cdata.validity, true_sel, false_sel);
 		}
 	}
 

package/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp

@@ -58,7 +58,7 @@ struct UnaryStringOperator {
 struct UnaryExecutor {
 private:
 	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteLoop(INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
+	static inline void ExecuteLoop(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
 	                               const SelectionVector *__restrict sel_vector, ValidityMask &mask,
 	                               ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
 #ifdef DEBUG
@@ -95,7 +95,7 @@ private:
 	}
 
 	template <class INPUT_TYPE, class RESULT_TYPE, class OPWRAPPER, class OP>
-	static inline void ExecuteFlat(INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
+	static inline void ExecuteFlat(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
 	                               ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
 		ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
 
@@ -175,7 +175,7 @@ private:
 
 			result.SetVectorType(VectorType::FLAT_VECTOR);
 			auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
-			auto ldata = (INPUT_TYPE *)vdata.data;
+			auto ldata = UnifiedVectorFormat::GetData<INPUT_TYPE>(vdata);
 
 			ExecuteLoop<INPUT_TYPE, RESULT_TYPE, OPWRAPPER, OP>(ldata, result_data, count, vdata.sel, vdata.validity,
 			                                                    FlatVector::Validity(result), dataptr, adds_nulls);

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/corr.hpp

@@ -24,49 +24,45 @@ struct CorrState {
 // CORR(y, x) = COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))
 struct CorrOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
-		STDDevBaseOperation::Initialize<StddevState>(&state->dev_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(&state->dev_pop_y);
+	static void Initialize(STATE &state) {
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
+		STDDevBaseOperation::Initialize<StddevState>(state.dev_pop_x);
+		STDDevBaseOperation::Initialize<StddevState>(state.dev_pop_y);
 	}
 
 	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, x_data, y_data,
-		                                                          amask, bmask, xidx, yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->dev_pop_x, aggr_input_data, x_data, amask,
-		                                                        xidx);
-		STDDevBaseOperation::Operation<B_TYPE, StddevState, OP>(&state->dev_pop_y, aggr_input_data, y_data, bmask,
-		                                                        yidx);
+	static void Operation(STATE &state, const A_TYPE &x_input, const B_TYPE &y_input, AggregateBinaryInput &idata) {
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x_input, y_input, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.dev_pop_x, x_input);
+		STDDevBaseOperation::Execute<B_TYPE, StddevState>(state.dev_pop_y, y_input);
 	}
 
 	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.dev_pop_x, &target->dev_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_y, &target->dev_pop_y, 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.dev_pop_x, target.dev_pop_x, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_y, target.dev_pop_y, 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->dev_pop_x.count == 0 || state->dev_pop_y.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.cov_pop.count == 0 || state.dev_pop_x.count == 0 || state.dev_pop_y.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
-			auto std_x = state->dev_pop_x.count > 1 ? sqrt(state->dev_pop_x.dsquared / state->dev_pop_x.count) : 0;
+			auto cov = state.cov_pop.co_moment / state.cov_pop.count;
+			auto std_x = state.dev_pop_x.count > 1 ? sqrt(state.dev_pop_x.dsquared / state.dev_pop_x.count) : 0;
 			if (!Value::DoubleIsFinite(std_x)) {
 				throw OutOfRangeException("STDDEV_POP for X is out of range!");
 			}
-			auto std_y = state->dev_pop_y.count > 1 ? sqrt(state->dev_pop_y.dsquared / state->dev_pop_y.count) : 0;
+			auto std_y = state.dev_pop_y.count > 1 ? sqrt(state.dev_pop_y.dsquared / state.dev_pop_y.count) : 0;
 			if (!Value::DoubleIsFinite(std_y)) {
 				throw OutOfRangeException("STDDEV_POP for Y is out of range!");
 			}
 			if (std_x * std_y == 0) {
-				mask.SetInvalid(idx);
+				finalize_data.ReturnNull();
 				return;
 			}
-			target[idx] = cov / (std_x * std_y);
+			target = cov / (std_x * std_y);
 		}
 	}
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/covar.hpp

@@ -21,51 +21,48 @@ struct CovarState {
 
 struct CovarOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->meanx = 0;
-		state->meany = 0;
-		state->co_moment = 0;
+	static void Initialize(STATE &state) {
+		state.count = 0;
+		state.meanx = 0;
+		state.meany = 0;
+		state.co_moment = 0;
 	}
 
 	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) {
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
 		// update running mean and d^2
-		const uint64_t n = ++(state->count);
+		const uint64_t n = ++(state.count);
 
-		const auto x = x_data[xidx];
-		const double dx = (x - state->meanx);
-		const double meanx = state->meanx + dx / n;
+		const double dx = (x - state.meanx);
+		const double meanx = state.meanx + dx / n;
 
-		const auto y = y_data[yidx];
-		const double dy = (y - state->meany);
-		const double meany = state->meany + dy / n;
+		const double dy = (y - state.meany);
+		const double meany = state.meany + dy / n;
 
-		const double C = state->co_moment + dx * (y - meany);
+		const double C = state.co_moment + dx * (y - meany);
 
-		state->meanx = meanx;
-		state->meany = meany;
-		state->co_moment = C;
+		state.meanx = meanx;
+		state.meany = meany;
+		state.co_moment = C;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (target->count == 0) {
-			*target = source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (target.count == 0) {
+			target = source;
 		} else if (source.count > 0) {
-			const auto count = target->count + source.count;
-			const auto meanx = (source.count * source.meanx + target->count * target->meanx) / count;
-			const auto meany = (source.count * source.meany + target->count * target->meany) / count;
+			const auto count = target.count + source.count;
+			const auto meanx = (source.count * source.meanx + target.count * target.meanx) / count;
+			const auto meany = (source.count * source.meany + target.count * target.meany) / count;
 
 			//  Schubert and Gertz SSDBM 2018, equation 21
-			const auto deltax = target->meanx - source.meanx;
-			const auto deltay = target->meany - source.meany;
-			target->co_moment =
-			    source.co_moment + target->co_moment + deltax * deltay * source.count * target->count / count;
-			target->meanx = meanx;
-			target->meany = meany;
-			target->count = count;
+			const auto deltax = target.meanx - source.meanx;
+			const auto deltay = target.meany - source.meany;
+			target.co_moment =
+			    source.co_moment + target.co_moment + deltax * deltay * source.count * target.count / count;
+			target.meanx = meanx;
+			target.meany = meany;
+			target.count = count;
 		}
 	}
 
@@ -76,22 +73,22 @@ struct CovarOperation {
 
 struct CovarPopOperation : public CovarOperation {
 	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->co_moment / state->count;
+			target = state.co_moment / state.count;
 		}
 	}
 };
 
 struct CovarSampOperation : public CovarOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if ((state->count) < 2) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count < 2) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->co_moment / (state->count - 1);
+			target = state.co_moment / (state.count - 1);
 		}
 	}
 };

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/stddev.hpp

@@ -23,46 +23,50 @@ struct StddevState {
 // method, DOI: 10.2307/1266577
 struct STDDevBaseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->mean = 0;
-		state->dsquared = 0;
+	static void Initialize(STATE &state) {
+		state.count = 0;
+		state.mean = 0;
+		state.dsquared = 0;
 	}
 
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input_data, ValidityMask &mask, idx_t idx) {
+	template <class INPUT_TYPE, class STATE>
+	static void Execute(STATE &state, const INPUT_TYPE &input) {
 		// update running mean and d^2
-		state->count++;
-		const double input = input_data[idx];
-		const double mean_differential = (input - state->mean) / state->count;
-		const double new_mean = state->mean + mean_differential;
-		const double dsquared_increment = (input - new_mean) * (input - state->mean);
-		const double new_dsquared = state->dsquared + dsquared_increment;
-
-		state->mean = new_mean;
-		state->dsquared = new_dsquared;
+		state.count++;
+		const double mean_differential = (input - state.mean) / state.count;
+		const double new_mean = state.mean + mean_differential;
+		const double dsquared_increment = (input - new_mean) * (input - state.mean);
+		const double new_dsquared = state.dsquared + dsquared_increment;
+
+		state.mean = new_mean;
+		state.dsquared = new_dsquared;
+
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
+		Execute(state, input);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input_data,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input_data, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (target->count == 0) {
-			*target = source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (target.count == 0) {
+			target = source;
 		} else if (source.count > 0) {
-			const auto count = target->count + source.count;
-			const auto mean = (source.count * source.mean + target->count * target->mean) / count;
-			const auto delta = source.mean - target->mean;
-			target->dsquared =
-			    source.dsquared + target->dsquared + delta * delta * source.count * target->count / count;
-			target->mean = mean;
-			target->count = count;
+			const auto count = target.count + source.count;
+			const auto mean = (source.count * source.mean + target.count * target.mean) / count;
+			const auto delta = source.mean - target.mean;
+			target.dsquared =
+			    source.dsquared + target.dsquared + delta * delta * source.count * target.count / count;
+			target.mean = mean;
+			target.count = count;
 		}
 	}
 
@@ -73,12 +77,12 @@ struct STDDevBaseOperation {
 
 struct VarSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count <= 1) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->dsquared / (state->count - 1);
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.dsquared / (state.count - 1);
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("VARSAMP is out of range!");
 			}
 		}
@@ -87,12 +91,12 @@ struct VarSampOperation : public STDDevBaseOperation {
 
 struct VarPopOperation : public STDDevBaseOperation {
 	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->count > 1 ? (state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.count > 1 ? (state.dsquared / state.count) : 0;
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 		}
@@ -101,12 +105,12 @@ struct VarPopOperation : public STDDevBaseOperation {
 
 struct STDDevSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count <= 1) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count <= 1) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = sqrt(state->dsquared / (state->count - 1));
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = sqrt(state.dsquared / (state.count - 1));
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("STDDEV_SAMP is out of range!");
 			}
 		}
@@ -115,12 +119,12 @@ struct STDDevSampOperation : public STDDevBaseOperation {
 
 struct STDDevPopOperation : public STDDevBaseOperation {
 	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->count > 1 ? sqrt(state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = state.count > 1 ? sqrt(state.dsquared / state.count) : 0;
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("STDDEV_POP is out of range!");
 			}
 		}
@@ -129,12 +133,12 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 
 struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
 	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] = sqrt(state->dsquared / state->count) / sqrt((state->count));
-			if (!Value::DoubleIsFinite(target[idx])) {
+			target = sqrt(state.dsquared / state.count) / sqrt((state.count));
+			if (!Value::DoubleIsFinite(target)) {
 				throw OutOfRangeException("SEM is out of range!");
 			}
 		}