duckdb 0.8.0 → 0.8.1-dev111.0

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 = (T *)input_data.data;
-				(*state->hist)[value[input_data.sel->get_index(i)]]++;
+				auto value = UnifiedVectorFormat::GetData<T>(input_data);
+				(*state.hist)[value[input_data.sel->get_index(i)]]++;
 			}
 		}
 	}
@@ -33,16 +32,15 @@ struct HistogramFunctor {
 struct HistogramStringFunctor {
 	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;
+		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();
 				}
-				auto value = (string_t *)input_data.data;
-				(*state->hist)[value[input_data.sel->get_index(i)].GetString()]++;
+				(*state.hist)[input_strings[input_data.sel->get_index(i)].GetString()]++;
 			}
 		}
 	}
@@ -56,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;
 		}
 	}
 
@@ -88,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;
 		}
 	}
@@ -125,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

@@ -35,7 +35,7 @@ struct ListBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ListBindData &)other_p;
+		auto &other = other_p.Cast<ListBindData>();
 		return stype == other.stype;
 	}
 };
@@ -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;
@@ -80,35 +79,35 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
 
-	auto states = (ListAggState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 	RecursiveFlatten(input, count);
 
 	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);
 	}
 }
 
 static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
 	UnifiedVectorFormat sdata;
 	state.ToUnifiedFormat(count, sdata);
-	auto states_ptr = (ListAggState **)sdata.data;
+	auto states_ptr = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 
 	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
 	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) {
@@ -125,7 +124,7 @@ static void ListFinalize(Vector &state_vector, AggregateInputData &aggr_input_da
                          idx_t offset) {
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = (ListAggState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 
@@ -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 &, A_TYPE *x_data, 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 &, A_TYPE *x_data, 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, A_TYPE *x_data, 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, A_TYPE *x_data, 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() {

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

@@ -16,30 +16,29 @@ struct RegrSState {
 
 struct RegrBaseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.var_pop.count == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
+		auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop)) {
 			throw OutOfRangeException("VARPOP is out of range!");
 		}
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= var_pop;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= var_pop;
 	}
 
 	static bool IgnoreNull() {
@@ -49,21 +48,17 @@ struct RegrBaseOperation {
 
 struct RegrSXXOperation : RegrBaseOperation {
 	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) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 };
 
 struct RegrSYYOperation : RegrBaseOperation {
 	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) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, x_data, bmask, xidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 };
 

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

@@ -14,33 +14,29 @@ struct RegrSXyState {
 
 struct RegrSXYOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, 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) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
 	}
 
 	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);
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, 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);
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, 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) {
-		CovarPopOperation::Finalize<T, CovarState>(result, aggr_input_data, &state->cov_pop, target, mask, idx);
-		auto cov_pop = target[idx];
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= cov_pop;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		CovarPopOperation::Finalize<T, CovarState>(state.cov_pop, target, finalize_data);
+		auto cov_pop = target;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= cov_pop;
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/core_functions/scalar/blob/base64.cpp

@@ -18,7 +18,7 @@ struct Base64DecodeOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 		auto result_size = Blob::FromBase64Size(input);
 		auto result_blob = StringVector::EmptyString(result, result_size);
-		Blob::FromBase64(input, (data_ptr_t)result_blob.GetDataWriteable(), result_size);
+		Blob::FromBase64(input, data_ptr_cast(result_blob.GetDataWriteable()), result_size);
 		result_blob.Finalize();
 		return result_blob;
 	}