duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -71,7 +71,7 @@ struct ReservoirQuantileBindData : public FunctionData {
 		writer.WriteField<int32_t>(bind_data.sample_size);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            AggregateFunction &bound_function) {
 		auto quantiles = reader.ReadRequiredList<double>();
 		auto sample_size = reader.ReadRequired<int32_t>();
@@ -84,60 +84,59 @@ struct ReservoirQuantileBindData : public FunctionData {
 
 struct ReservoirQuantileOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->v = nullptr;
-		state->len = 0;
-		state->pos = 0;
-		state->r_samp = nullptr;
+	static void Initialize(STATE &state) {
+		state.v = nullptr;
+		state.len = 0;
+		state.pos = 0;
+		state.r_samp = nullptr;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              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, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *data, ValidityMask &mask,
-	                      idx_t idx) {
-		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
-		if (state->pos == 0) {
-			state->Resize(bind_data.sample_size);
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		auto &bind_data = unary_input.input.bind_data->template Cast<ReservoirQuantileBindData>();
+		if (state.pos == 0) {
+			state.Resize(bind_data.sample_size);
 		}
-		if (!state->r_samp) {
-			state->r_samp = new BaseReservoirSampling();
+		if (!state.r_samp) {
+			state.r_samp = new BaseReservoirSampling();
 		}
-		D_ASSERT(state->v);
-		state->FillReservoir(bind_data.sample_size, data[idx]);
+		D_ASSERT(state.v);
+		state.FillReservoir(bind_data.sample_size, input);
 	}
 
 	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.pos == 0) {
 			return;
 		}
-		if (target->pos == 0) {
-			target->Resize(source.len);
+		if (target.pos == 0) {
+			target.Resize(source.len);
 		}
-		if (!target->r_samp) {
-			target->r_samp = new BaseReservoirSampling();
+		if (!target.r_samp) {
+			target.r_samp = new BaseReservoirSampling();
 		}
 		for (idx_t src_idx = 0; src_idx < source.pos; src_idx++) {
-			target->FillReservoir(target->len, source.v[src_idx]);
+			target.FillReservoir(target.len, source.v[src_idx]);
 		}
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->v) {
-			free(state->v);
-			state->v = nullptr;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.v) {
+			free(state.v);
+			state.v = nullptr;
 		}
-		if (state->r_samp) {
-			delete state->r_samp;
-			state->r_samp = nullptr;
+		if (state.r_samp) {
+			delete state.r_samp;
+			state.r_samp = nullptr;
 		}
 	}
 
@@ -147,21 +146,20 @@ struct ReservoirQuantileOperation {
 };
 
 struct ReservoirQuantileScalarOperation : public ReservoirQuantileOperation {
-	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, TARGET_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
+	template <class T, class STATE>
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.pos == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		D_ASSERT(state->v);
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
-		auto v_t = state->v;
+		D_ASSERT(state.v);
+		D_ASSERT(finalize_data.input.bind_data);
+		auto &bind_data = finalize_data.input.bind_data->template Cast<ReservoirQuantileBindData>();
+		auto v_t = state.v;
 		D_ASSERT(bind_data.quantiles.size() == 1);
-		auto offset = (idx_t)((double)(state->pos - 1) * bind_data.quantiles[0]);
-		std::nth_element(v_t, v_t + offset, v_t + state->pos);
-		target[idx] = v_t[offset];
+		auto offset = (idx_t)((double)(state.pos - 1) * bind_data.quantiles[0]);
+		std::nth_element(v_t, v_t + offset, v_t + state.pos);
+		target = v_t[offset];
 	}
 };
 
@@ -206,69 +204,35 @@ AggregateFunction GetReservoirQuantileAggregateFunction(PhysicalType type) {
 
 template <class CHILD_TYPE>
 struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
-
-	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
+	template <class T, class STATE>
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.pos == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
 
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
+		D_ASSERT(finalize_data.input.bind_data);
+		auto &bind_data = finalize_data.input.bind_data->template Cast<ReservoirQuantileBindData>();
 
-		auto &result = ListVector::GetEntry(result_list);
-		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data.quantiles.size());
+		auto &result = ListVector::GetEntry(finalize_data.result);
+		auto ridx = ListVector::GetListSize(finalize_data.result);
+		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
-		auto v_t = state->v;
+		auto v_t = state.v;
 		D_ASSERT(v_t);
 
-		auto &entry = target[idx];
+		auto &entry = target;
 		entry.offset = ridx;
 		entry.length = bind_data.quantiles.size();
 		for (size_t q = 0; q < entry.length; ++q) {
 			const auto &quantile = bind_data.quantiles[q];
-			auto offset = (idx_t)((double)(state->pos - 1) * quantile);
-			std::nth_element(v_t, v_t + offset, v_t + state->pos);
+			auto offset = (idx_t)((double)(state.pos - 1) * quantile);
+			std::nth_element(v_t, v_t + offset, v_t + state.pos);
 			rdata[ridx + q] = v_t[offset];
 		}
 
-		ListVector::SetListSize(result_list, entry.offset + entry.length);
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, // NOLINT
-	                         idx_t offset) {
-		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto &bind_data = aggr_input_data.bind_data->Cast<ReservoirQuantileBindData>();
-
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data.quantiles.size());
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto &mask = ConstantVector::Validity(result);
-			Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[0], rdata, mask, 0);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data.quantiles.size());
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			auto &mask = FlatVector::Validity(result);
-			for (idx_t i = 0; i < count; i++) {
-				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
-			}
-		}
-
-		result.Verify(count);
+		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
 	}
 };
 
@@ -278,8 +242,8 @@ static AggregateFunction ReservoirQuantileListAggregate(const LogicalType &input
 	return AggregateFunction(
 	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
 	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    OP::template FinalizeList<STATE, RESULT_TYPE>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>, nullptr,
-	    AggregateFunction::StateDestroy<STATE, OP>);
+	    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>,
+	    nullptr, AggregateFunction::StateDestroy<STATE, OP>);
 }
 
 template <typename INPUT_TYPE, typename SAVE_TYPE>

package/src/duckdb/src/core_functions/aggregate/nested/histogram.cpp

@@ -10,16 +10,15 @@ namespace duckdb {
 struct HistogramFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
 	static void HistogramUpdate(UnifiedVectorFormat &sdata, UnifiedVectorFormat &input_data, idx_t count) {
-
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
 			if (input_data.validity.RowIsValid(input_data.sel->get_index(i))) {
-				auto state = states[sdata.sel->get_index(i)];
-				if (!state->hist) {
-					state->hist = new MAP_TYPE();
+				auto &state = *states[sdata.sel->get_index(i)];
+				if (!state.hist) {
+					state.hist = new MAP_TYPE();
 				}
 				auto value = UnifiedVectorFormat::GetData<T>(input_data);
-				(*state->hist)[value[input_data.sel->get_index(i)]]++;
+				(*state.hist)[value[input_data.sel->get_index(i)]]++;
 			}
 		}
 	}
@@ -37,11 +36,11 @@ struct HistogramStringFunctor {
 		auto input_strings = UnifiedVectorFormat::GetData<string_t>(input_data);
 		for (idx_t i = 0; i < count; i++) {
 			if (input_data.validity.RowIsValid(input_data.sel->get_index(i))) {
-				auto state = states[sdata.sel->get_index(i)];
-				if (!state->hist) {
-					state->hist = new MAP_TYPE();
+				auto &state = *states[sdata.sel->get_index(i)];
+				if (!state.hist) {
+					state.hist = new MAP_TYPE();
 				}
-				(*state->hist)[input_strings[input_data.sel->get_index(i)].GetString()]++;
+				(*state.hist)[input_strings[input_data.sel->get_index(i)].GetString()]++;
 			}
 		}
 	}
@@ -55,14 +54,14 @@ struct HistogramStringFunctor {
 
 struct HistogramFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->hist = nullptr;
+	static void Initialize(STATE &state) {
+		state.hist = nullptr;
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->hist) {
-			delete state->hist;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.hist) {
+			delete state.hist;
 		}
 	}
 
@@ -87,25 +86,25 @@ static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &, idx_t
 }
 
 template <class T, class MAP_TYPE>
-static void HistogramCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
+static void HistogramCombineFunction(Vector &state_vector, Vector &combined, AggregateInputData &, idx_t count) {
 
 	UnifiedVectorFormat sdata;
-	state.ToUnifiedFormat(count, sdata);
+	state_vector.ToUnifiedFormat(count, sdata);
 	auto states_ptr = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 	auto combined_ptr = FlatVector::GetData<HistogramAggState<T, MAP_TYPE> *>(combined);
 
 	for (idx_t i = 0; i < count; i++) {
-		auto state = states_ptr[sdata.sel->get_index(i)];
-		if (!state->hist) {
+		auto &state = *states_ptr[sdata.sel->get_index(i)];
+		if (!state.hist) {
 			continue;
 		}
 		if (!combined_ptr[i]->hist) {
 			combined_ptr[i]->hist = new MAP_TYPE();
 		}
 		D_ASSERT(combined_ptr[i]->hist);
-		D_ASSERT(state->hist);
-		for (auto &entry : *state->hist) {
+		D_ASSERT(state.hist);
+		for (auto &entry : *state.hist) {
 			(*combined_ptr[i]->hist)[entry.first] += entry.second;
 		}
 	}
@@ -124,13 +123,13 @@ static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &
 
 	for (idx_t i = 0; i < count; i++) {
 		const auto rid = i + offset;
-		auto state = states[sdata.sel->get_index(i)];
-		if (!state->hist) {
+		auto &state = *states[sdata.sel->get_index(i)];
+		if (!state.hist) {
 			mask.SetInvalid(rid);
 			continue;
 		}
 
-		for (auto &entry : *state->hist) {
+		for (auto &entry : *state.hist) {
 			Value bucket_value = OP::template HistogramFinalize<T>(entry.first);
 			auto count_value = Value::CreateValue(entry.second);
 			auto struct_value =

package/src/duckdb/src/core_functions/aggregate/nested/list.cpp

@@ -55,17 +55,16 @@ struct ListAggState {
 
 struct ListFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->linked_list.total_capacity = 0;
-		state->linked_list.first_segment = nullptr;
-		state->linked_list.last_segment = nullptr;
+	static void Initialize(STATE &state) {
+		state.linked_list.total_capacity = 0;
+		state.linked_list.first_segment = nullptr;
+		state.linked_list.last_segment = nullptr;
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		D_ASSERT(state);
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
 		auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
-		list_bind_data.functions.Destroy(aggr_input_data.allocator, state->linked_list);
+		list_bind_data.functions.Destroy(aggr_input_data.allocator, state.linked_list);
 	}
 	static bool IgnoreNull() {
 		return false;
@@ -86,8 +85,8 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
 	for (idx_t i = 0; i < count; i++) {
-		auto state = states[sdata.sel->get_index(i)];
-		list_bind_data.functions.AppendRow(aggr_input_data.allocator, state->linked_list, input, i, count);
+		auto &state = *states[sdata.sel->get_index(i)];
+		list_bind_data.functions.AppendRow(aggr_input_data.allocator, state.linked_list, input, i, count);
 	}
 }
 
@@ -100,15 +99,15 @@ static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputD
 
 	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
 	for (idx_t i = 0; i < count; i++) {
-		auto state = states_ptr[sdata.sel->get_index(i)];
-		if (state->linked_list.total_capacity == 0) {
+		auto &state = *states_ptr[sdata.sel->get_index(i)];
+		if (state.linked_list.total_capacity == 0) {
 			// NULL, no need to append.
 			continue;
 		}
 
 		// copy the linked list of the state
-		auto copied_linked_list = LinkedList(state->linked_list.total_capacity, nullptr, nullptr);
-		list_bind_data.functions.CopyLinkedList(state->linked_list, copied_linked_list, aggr_input_data.allocator);
+		auto copied_linked_list = LinkedList(state.linked_list.total_capacity, nullptr, nullptr);
+		list_bind_data.functions.CopyLinkedList(state.linked_list, copied_linked_list, aggr_input_data.allocator);
 
 		// append the copied linked list to the combined state
 		if (combined_ptr[i]->linked_list.last_segment) {
@@ -136,16 +135,16 @@ static void ListFinalize(Vector &state_vector, AggregateInputData &aggr_input_da
 	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 	// first iterate over all of the entries and set up the list entries, plus get the newly required total length
 	for (idx_t i = 0; i < count; i++) {
-		auto state = states[sdata.sel->get_index(i)];
+		auto &state = *states[sdata.sel->get_index(i)];
 		const auto rid = i + offset;
 		result_data[rid].offset = total_len;
-		if (state->linked_list.total_capacity == 0) {
+		if (state.linked_list.total_capacity == 0) {
 			mask.SetInvalid(rid);
 			result_data[rid].length = 0;
 			continue;
 		}
 		// set the length and offset of this list in the result vector
-		auto total_capacity = state->linked_list.total_capacity;
+		auto total_capacity = state.linked_list.total_capacity;
 		result_data[rid].length = total_capacity;
 		total_len += total_capacity;
 	}
@@ -153,14 +152,14 @@ static void ListFinalize(Vector &state_vector, AggregateInputData &aggr_input_da
 	ListVector::Reserve(result, total_len);
 	auto &result_child = ListVector::GetEntry(result);
 	for (idx_t i = 0; i < count; i++) {
-		auto state = states[sdata.sel->get_index(i)];
+		auto &state = *states[sdata.sel->get_index(i)];
 		const auto rid = i + offset;
-		if (state->linked_list.total_capacity == 0) {
+		if (state.linked_list.total_capacity == 0) {
 			continue;
 		}
 
 		idx_t current_offset = result_data[rid].offset;
-		list_bind_data.functions.BuildListVector(state->linked_list, result_child, current_offset);
+		list_bind_data.functions.BuildListVector(state.linked_list, result_child, current_offset);
 	}
 	ListVector::SetListSize(result, total_len);
 }

package/src/duckdb/src/core_functions/aggregate/regression/regr_avg.cpp

@@ -12,23 +12,23 @@ struct RegrState {
 
 struct RegrAvgFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->sum = 0;
-		state->count = 0;
+	static void Initialize(STATE &state) {
+		state.sum = 0;
+		state.count = 0;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->sum += source.sum;
-		target->count += source.count;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target.sum += source.sum;
+		target.count += source.count;
 	}
 
 	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->sum / (double)state->count;
+			target = state.sum / (double)state.count;
 		}
 	}
 	static bool IgnoreNull() {
@@ -37,19 +37,17 @@ struct RegrAvgFunction {
 };
 struct RegrAvgXFunction : RegrAvgFunction {
 	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) {
-		state->sum += y_data[yidx];
-		state->count++;
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		state.sum += y;
+		state.count++;
 	}
 };
 
 struct RegrAvgYFunction : RegrAvgFunction {
 	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) {
-		state->sum += x_data[xidx];
-		state->count++;
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		state.sum += x;
+		state.count++;
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/regression/regr_intercept.cpp

@@ -15,42 +15,39 @@ struct RegrInterceptState {
 
 struct RegrInterceptOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->count = 0;
-		state->sum_x = 0;
-		state->sum_y = 0;
-		RegrSlopeOperation::Initialize<RegrSlopeState>(&state->slope);
+	static void Initialize(STATE &state) {
+		state.count = 0;
+		state.sum_x = 0;
+		state.sum_y = 0;
+		RegrSlopeOperation::Initialize<RegrSlopeState>(state.slope);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		state->count++;
-		state->sum_x += y_data[yidx];
-		state->sum_y += x_data[xidx];
-		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(&state->slope, aggr_input_data, x_data,
-		                                                                  y_data, amask, bmask, xidx, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		state.count++;
+		state.sum_x += y;
+		state.sum_y += x;
+		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(state.slope, x, y, idata);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		target->count += source.count;
-		target->sum_x += source.sum_x;
-		target->sum_y += source.sum_y;
-		RegrSlopeOperation::Combine<RegrSlopeState, OP>(source.slope, &target->slope, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		target.count += source.count;
+		target.sum_x += source.sum_x;
+		target.sum_y += source.sum_y;
+		RegrSlopeOperation::Combine<RegrSlopeState, OP>(source.slope, target.slope, aggr_input_data);
 	}
 
 	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();
 			return;
 		}
-		RegrSlopeOperation::Finalize<T, RegrSlopeState>(result, aggr_input_data, &state->slope, target, mask, idx);
-		auto x_avg = state->sum_x / state->count;
-		auto y_avg = state->sum_y / state->count;
-		target[idx] = y_avg - target[idx] * x_avg;
+		RegrSlopeOperation::Finalize<T, RegrSlopeState>(state.slope, target, finalize_data);
+		auto x_avg = state.sum_x / state.count;
+		auto y_avg = state.sum_y / state.count;
+		target = y_avg - target * x_avg;
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/core_functions/aggregate/regression/regr_r2.cpp

@@ -17,51 +17,46 @@ struct RegrR2State {
 
 struct RegrR2Operation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		CorrOperation::Initialize<CorrState>(&state->corr);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_y);
+	static void Initialize(STATE &state) {
+		CorrOperation::Initialize<CorrState>(state.corr);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_x);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_y);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(&state->corr, aggr_input_data, y_data, x_data, bmask,
-		                                                        amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_x, aggr_input_data, y_data, bmask,
-		                                                        yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_y, aggr_input_data, x_data, amask,
-		                                                        xidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(state.corr, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_x, y);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_y, x);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CorrOperation::Combine<CorrState, OP>(source.corr, &target->corr, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, &target->var_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, &target->var_pop_y, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CorrOperation::Combine<CorrState, OP>(source.corr, target.corr, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, target.var_pop_x, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, target.var_pop_y, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		auto var_pop_x = state->var_pop_x.count > 1 ? (state->var_pop_x.dsquared / state->var_pop_x.count) : 0;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		auto var_pop_x = state.var_pop_x.count > 1 ? (state.var_pop_x.dsquared / state.var_pop_x.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop_x)) {
 			throw OutOfRangeException("VARPOP(X) is out of range!");
 		}
 		if (var_pop_x == 0) {
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto var_pop_y = state->var_pop_y.count > 1 ? (state->var_pop_y.dsquared / state->var_pop_y.count) : 0;
+		auto var_pop_y = state.var_pop_y.count > 1 ? (state.var_pop_y.dsquared / state.var_pop_y.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop_y)) {
 			throw OutOfRangeException("VARPOP(Y) is out of range!");
 		}
 		if (var_pop_y == 0) {
-			target[idx] = 1;
+			target = 1;
 			return;
 		}
-		CorrOperation::Finalize<T, CorrState>(result, aggr_input_data, &state->corr, target, mask, idx);
-		target[idx] = pow(target[idx], 2);
+		CorrOperation::Finalize<T, CorrState>(state.corr, target, finalize_data);
+		target = pow(target, 2);
 	}
 
 	static bool IgnoreNull() {