npm - duckdb - Versions diffs - 0.4.1-dev104.0 → 0.4.1-dev108.0 - Mend

duckdb 0.4.1-dev104.0 → 0.4.1-dev108.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json +1 -1
package/src/duckdb.cpp +344 -318
package/src/duckdb.hpp +581 -563
package/src/parquet-amalgamation.cpp +36759 -36759

package/src/duckdb.cpp CHANGED Viewed

@@ -31066,7 +31066,8 @@ void RowOperations::DestroyStates(RowLayout &layout, Vector &addresses, idx_t co
 void RowOperations::UpdateStates(AggregateObject &aggr, Vector &addresses, DataChunk &payload, idx_t arg_idx,
                                  idx_t count) {
-	aggr.function.update(aggr.child_count == 0 ? nullptr : &payload.data[arg_idx], aggr.bind_data, aggr.child_count,
+	AggregateInputData aggr_input_data(aggr.bind_data);
+	aggr.function.update(aggr.child_count == 0 ? nullptr : &payload.data[arg_idx], aggr_input_data, aggr.child_count,
 	                     addresses, count);
 }
@@ -31096,7 +31097,8 @@ void RowOperations::CombineStates(RowLayout &layout, Vector &sources, Vector &ta
 	VectorOperations::AddInPlace(targets, layout.GetAggrOffset(), count);
 	for (auto &aggr : layout.GetAggregates()) {
 		D_ASSERT(aggr.function.combine);
-		aggr.function.combine(sources, targets, aggr.bind_data, count);
+		AggregateInputData aggr_input_data(aggr.bind_data);
+		aggr.function.combine(sources, targets, aggr_input_data, count);
 		// Move to the next aggregate states
 		VectorOperations::AddInPlace(sources, aggr.payload_size, count);
@@ -31112,7 +31114,8 @@ void RowOperations::FinalizeStates(RowLayout &layout, Vector &addresses, DataChu
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &target = result.data[aggr_idx + i];
 		auto &aggr = aggregates[i];
-		aggr.function.finalize(addresses, aggr.bind_data, target, result.size(), 0);
+		AggregateInputData aggr_input_data(aggr.bind_data);
+		aggr.function.finalize(addresses, aggr_input_data, target, result.size(), 0);
 		// Move to the next aggregate state
 		VectorOperations::AddInPlace(addresses, aggr.payload_size, result.size());
@@ -59646,9 +59649,9 @@ SinkResultType PhysicalSimpleAggregate::Sink(ExecutionContext &context, GlobalSi
 			}
 		}
-		aggregate.function.simple_update(payload_cnt == 0 ? nullptr : &payload_chunk.data[payload_idx],
-		                                 aggregate.bind_info.get(), payload_cnt, sink.state.aggregates[aggr_idx].get(),
-		                                 payload_chunk.size());
+		AggregateInputData aggr_input_data(aggregate.bind_info.get());
+		aggregate.function.simple_update(payload_cnt == 0 ? nullptr : &payload_chunk.data[payload_idx], aggr_input_data,
+		                                 payload_cnt, sink.state.aggregates[aggr_idx].get(), payload_chunk.size());
 		payload_idx += payload_cnt;
 	}
 	return SinkResultType::NEED_MORE_INPUT;
@@ -59671,7 +59674,8 @@ void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState
 		Vector source_state(Value::POINTER((uintptr_t)source.state.aggregates[aggr_idx].get()));
 		Vector dest_state(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
-		aggregate.function.combine(source_state, dest_state, aggregate.bind_info.get(), 1);
+		AggregateInputData aggr_input_data(aggregate.bind_info.get());
+		aggregate.function.combine(source_state, dest_state, aggr_input_data, 1);
 	}
 	auto &client_profiler = QueryProfiler::Get(context.client);
@@ -59718,7 +59722,8 @@ void PhysicalSimpleAggregate::GetData(ExecutionContext &context, DataChunk &chun
 		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
 		Vector state_vector(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
-		aggregate.function.finalize(state_vector, aggregate.bind_info.get(), chunk.data[aggr_idx], 1, 0);
+		AggregateInputData aggr_input_data(aggregate.bind_info.get());
+		aggregate.function.finalize(state_vector, aggr_input_data, chunk.data[aggr_idx], 1, 0);
 	}
 	state.finished = true;
 }
@@ -79249,8 +79254,9 @@ void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &ch
 			auto aggr_state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
 			aggr.function.initialize(aggr_state.get());
+			AggregateInputData aggr_input_data(aggr.bind_info.get());
 			Vector state_vector(Value::POINTER((uintptr_t)aggr_state.get()));
-			aggr.function.finalize(state_vector, aggr.bind_info.get(), chunk.data[null_groups.size() + i], 1, 0);
+			aggr.function.finalize(state_vector, aggr_input_data, chunk.data[null_groups.size() + i], 1, 0);
 			if (aggr.function.destructor) {
 				aggr.function.destructor(state_vector, 1);
 			}
@@ -79587,7 +79593,8 @@ void WindowSegmentTree::AggregateInit() {
 }
 void WindowSegmentTree::AggegateFinal(Vector &result, idx_t rid) {
-	aggregate.finalize(statev, bind_info, result, 1, rid);
+	AggregateInputData aggr_input_data(bind_info);
+	aggregate.finalize(statev, aggr_input_data, result, 1, rid);
 	if (aggregate.destructor) {
 		aggregate.destructor(statev, 1);
@@ -79654,7 +79661,8 @@ void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end)
 	Vector s(statep, 0);
 	if (l_idx == 0) {
 		ExtractFrame(begin, end);
-		aggregate.update(&inputs.data[0], bind_info, input_ref->ColumnCount(), s, inputs.size());
+		AggregateInputData aggr_input_data(bind_info);
+		aggregate.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
 	} else {
 		inputs.Reset();
 		inputs.SetCardinality(end - begin);
@@ -79667,7 +79675,8 @@ void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end)
 			pdata[i] = begin_ptr + i * state.size();
 		}
 		v.Verify(inputs.size());
-		aggregate.combine(v, s, bind_info, inputs.size());
+		AggregateInputData aggr_input_data(bind_info);
+		aggregate.combine(v, s, aggr_input_data, inputs.size());
 	}
 }
@@ -79769,8 +79778,9 @@ void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t en
 		active = FrameBounds(active_chunks.first * STANDARD_VECTOR_SIZE,
 		                     MinValue((active_chunks.second + 1) * STANDARD_VECTOR_SIZE, coll.Count()));
-		aggregate.window(inputs.data.data(), filter_mask, bind_info, inputs.ColumnCount(), state.data(), frame, prev,
-		                 result, rid, active.first);
+		AggregateInputData aggr_input_data(bind_info);
+		aggregate.window(inputs.data.data(), filter_mask, aggr_input_data, inputs.ColumnCount(), state.data(), frame,
+		                 prev, result, rid, active.first);
 		return;
 	}
@@ -80004,18 +80014,18 @@ struct BaseSumOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		STATEOP::template Combine<STATE>(source, target, bind_data);
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
+		STATEOP::template Combine<STATE>(source, target, aggr_input_data);
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		STATEOP::template AddValues<STATE>(state, 1);
 		ADDOP::template AddNumber<STATE, INPUT_TYPE>(*state, input[idx]);
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
 	                              idx_t count) {
 		STATEOP::template AddValues<STATE>(state, count);
 		ADDOP::template AddConstant<STATE, INPUT_TYPE>(*state, *input, count);
@@ -80090,7 +80100,7 @@ struct AverageSetOperation {
 		state->Initialize();
 	}
 	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		target->Combine(source);
 	}
 	template <class STATE>
@@ -80111,12 +80121,12 @@ 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, FunctionData *bind_data, STATE *state, T *target, ValidityMask &mask,
-	                     idx_t idx) {
+	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);
 		} else {
-			double divident = GetAverageDivident<double>(state->count, bind_data);
+			double divident = GetAverageDivident<double>(state->count, aggr_input_data.bind_data);
 			target[idx] = double(state->value) / divident;
 		}
 	}
@@ -80124,12 +80134,12 @@ struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, Re
 struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data, STATE *state, T *target, ValidityMask &mask,
-	                     idx_t idx) {
+	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);
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, bind_data);
+			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
 			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
 		}
 	}
@@ -80137,12 +80147,12 @@ struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperat
 struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data, STATE *state, T *target, ValidityMask &mask,
-	                     idx_t idx) {
+	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);
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, bind_data);
+			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
 			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
 		}
 	}
@@ -80150,7 +80160,7 @@ struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, Re
 struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80164,7 +80174,7 @@ struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, Re
 struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, KahanAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80266,7 +80276,7 @@ struct CovarOperation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
+	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
 	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		// update running mean and d^2
 		const uint64_t n = ++(state->count);
@@ -80287,7 +80297,7 @@ struct CovarOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (target->count == 0) {
 			*target = source;
 		} else if (source.count > 0) {
@@ -80313,7 +80323,7 @@ struct CovarOperation {
 struct CovarPopOperation : public CovarOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80324,7 +80334,7 @@ struct CovarPopOperation : public CovarOperation {
 struct CovarSampOperation : public CovarOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if ((state->count) < 2) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80366,8 +80376,7 @@ struct STDDevBaseOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input_data, ValidityMask &mask,
-	                      idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input_data, ValidityMask &mask, idx_t idx) {
 		// update running mean and d^2
 		state->count++;
 		const double input = input_data[idx];
@@ -80381,15 +80390,15 @@ struct STDDevBaseOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input_data, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input_data,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input_data, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input_data, mask, 0);
 		}
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (target->count == 0) {
 			*target = source;
 		} else if (source.count > 0) {
@@ -80410,7 +80419,7 @@ struct STDDevBaseOperation {
 struct VarSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count <= 1) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80424,7 +80433,7 @@ struct VarSampOperation : public STDDevBaseOperation {
 struct VarPopOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80438,7 +80447,7 @@ struct VarPopOperation : public STDDevBaseOperation {
 struct STDDevSampOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count <= 1) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80452,7 +80461,7 @@ struct STDDevSampOperation : public STDDevBaseOperation {
 struct STDDevPopOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80466,7 +80475,7 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80513,23 +80522,25 @@ struct CorrOperation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, x_data, y_data, amask,
-		                                                          bmask, xidx, yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->dev_pop_x, bind_data, x_data, amask, xidx);
-		STDDevBaseOperation::Operation<B_TYPE, StddevState, OP>(&state->dev_pop_y, bind_data, y_data, bmask, yidx);
+	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);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_x, &target->dev_pop_x, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.dev_pop_y, &target->dev_pop_y, bind_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, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	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);
 		} else {
@@ -80688,7 +80699,7 @@ struct ApproxCountDistinctFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.log) {
 			return;
 		}
@@ -80703,7 +80714,7 @@ struct ApproxCountDistinctFunction {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->log) {
 			target[idx] = state->log->Count();
 		} else {
@@ -80722,7 +80733,7 @@ struct ApproxCountDistinctFunction {
 	}
 };
-static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], FunctionData *bind_data, idx_t input_count,
+static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
                                                     data_ptr_t state, idx_t count) {
 	D_ASSERT(input_count == 1);
@@ -80741,7 +80752,7 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], FunctionDat
 	agg_state->log->AddToLog(vdata, count, indices, counts);
 }
-static void ApproxCountDistinctUpdateFunction(Vector inputs[], FunctionData *bind_data, idx_t input_count,
+static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count,
                                               Vector &state_vector, idx_t count) {
 	D_ASSERT(input_count == 1);
@@ -80861,7 +80872,7 @@ struct ArgMinMaxBase {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
+	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
 	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		if (!state->is_initialized) {
 			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data[xidx], false);
@@ -80881,7 +80892,7 @@ struct ArgMinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.is_initialized) {
 			return;
 		}
@@ -80900,7 +80911,7 @@ struct ArgMinMaxBase {
 template <class COMPARATOR>
 struct StringArgMinMax : public ArgMinMaxBase<COMPARATOR> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_initialized) {
 			mask.SetInvalid(idx);
 		} else {
@@ -80912,7 +80923,7 @@ struct StringArgMinMax : public ArgMinMaxBase<COMPARATOR> {
 template <class COMPARATOR>
 struct NumericArgMinMax : public ArgMinMaxBase<COMPARATOR> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_initialized) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81051,7 +81062,7 @@ struct BitAndOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			state->is_set = true;
 			state->value = input[idx];
@@ -81061,14 +81072,14 @@ struct BitAndOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81077,7 +81088,7 @@ struct BitAndOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.is_set) {
 			// source is NULL, nothing to do.
 			return;
@@ -81111,7 +81122,7 @@ struct BitOrOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			state->is_set = true;
 			state->value = input[idx];
@@ -81121,14 +81132,14 @@ struct BitOrOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81137,7 +81148,7 @@ struct BitOrOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.is_set) {
 			// source is NULL, nothing to do.
 			return;
@@ -81171,7 +81182,7 @@ struct BitXorOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			state->is_set = true;
 			state->value = input[idx];
@@ -81181,14 +81192,14 @@ struct BitXorOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		//  count is irrelevant
-		Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81197,7 +81208,7 @@ struct BitXorOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.is_set) {
 			// source is NULL, nothing to do.
 			return;
@@ -81245,13 +81256,13 @@ struct BoolAndFunFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		target->val = target->val && source.val;
 		target->empty = target->empty && source.empty;
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->empty) {
 			mask.SetInvalid(idx);
 			return;
@@ -81260,16 +81271,16 @@ struct BoolAndFunFunction {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		state->empty = false;
 		state->val = input[idx] && state->val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	static bool IgnoreNull() {
@@ -81285,13 +81296,13 @@ struct BoolOrFunFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		target->val = target->val || source.val;
 		target->empty = target->empty && source.empty;
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->empty) {
 			mask.SetInvalid(idx);
 			return;
@@ -81299,16 +81310,16 @@ struct BoolOrFunFunction {
 		target[idx] = state->val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		state->empty = false;
 		state->val = input[idx] || state->val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
@@ -81361,36 +81372,36 @@ struct BaseCountFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		*target += source;
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		target[idx] = *state;
 	}
 };
 struct CountStarFunction : public BaseCountFunction {
 	template <class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, idx_t idx) {
 		*state += 1;
 	}
 	template <class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &, idx_t count) {
 		*state += count;
 	}
 };
 struct CountFunction : public BaseCountFunction {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		*state += 1;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
 	                              idx_t count) {
 		*state += count;
 	}
@@ -81478,7 +81489,7 @@ struct EntropyFunctionBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.distinct) {
 			return;
 		}
@@ -81494,7 +81505,7 @@ struct EntropyFunctionBase {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		double count = state->count;
 		if (state->distinct) {
 			double entropy = 0;
@@ -81520,7 +81531,7 @@ struct EntropyFunctionBase {
 struct EntropyFunction : EntropyFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->distinct) {
 			state->distinct = new unordered_map<INPUT_TYPE, idx_t>();
 		}
@@ -81528,17 +81539,17 @@ struct EntropyFunction : EntropyFunctionBase {
 		state->count++;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 };
 struct EntropyFunctionString : EntropyFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->distinct) {
 			state->distinct = new unordered_map<string, idx_t>();
 		}
@@ -81548,10 +81559,10 @@ struct EntropyFunctionString : EntropyFunctionBase {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 };
@@ -81644,7 +81655,7 @@ struct FirstFunctionBase {
 template <bool LAST>
 struct FirstFunction : public FirstFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (LAST || !state->is_set) {
 			state->is_set = true;
 			if (!mask.RowIsValid(idx)) {
@@ -81657,20 +81668,20 @@ struct FirstFunction : public FirstFunctionBase {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
+		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!target->is_set) {
 			*target = source;
 		}
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set || state->is_null) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81701,27 +81712,27 @@ struct FirstFunctionString : public FirstFunctionBase {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (LAST || !state->is_set) {
 			SetValue(state, input[idx], !mask.RowIsValid(idx));
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
+		Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.is_set && (LAST || !target->is_set)) {
 			SetValue(target, source.value, source.is_null);
 		}
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_set || state->is_null) {
 			mask.SetInvalid(idx);
 		} else {
@@ -81769,7 +81780,7 @@ struct FirstVectorFunction {
 		VectorOperations::Copy(input, *state->value, sel, 1, 0, 0);
 	}
-	static void Update(Vector inputs[], FunctionData *, idx_t input_count, Vector &state_vector, idx_t count) {
+	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
 		auto &input = inputs[0];
 		VectorData sdata;
 		state_vector.Orrify(count, sdata);
@@ -81784,14 +81795,14 @@ struct FirstVectorFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.value && (LAST || !target->value)) {
 			SetValue(target, *source.value, 0);
 		}
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->value) {
 			// we need to use FlatVector::SetNull here
 			// since for STRUCT columns only setting the validity mask of the struct is incorrect
@@ -81957,15 +81968,15 @@ struct KurtosisOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->n++;
 		state->sum += data[idx];
 		state->sum_sqr += pow(data[idx], 2);
@@ -81974,7 +81985,7 @@ struct KurtosisOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.n == 0) {
 			return;
 		}
@@ -81986,7 +81997,7 @@ struct KurtosisOperation {
 	}
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
 	                     idx_t idx) {
 		auto n = (double)state->n;
 		if (n <= 3) {
@@ -82094,7 +82105,7 @@ struct MinMaxBase {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
 	                              idx_t count) {
 		D_ASSERT(mask.RowIsValid(0));
 		if (!state->isset) {
@@ -82106,7 +82117,7 @@ struct MinMaxBase {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			OP::template Assign<INPUT_TYPE, STATE>(state, input[idx]);
 			state->isset = true;
@@ -82127,7 +82138,7 @@ struct NumericMinMaxBase : public MinMaxBase {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		mask.Set(idx, state->isset);
 		target[idx] = state->value;
 	}
@@ -82142,7 +82153,7 @@ struct MinOperation : public NumericMinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
@@ -82165,7 +82176,7 @@ struct MaxOperation : public NumericMinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
@@ -82203,7 +82214,7 @@ struct StringMinMaxBase : public MinMaxBase {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
@@ -82212,7 +82223,7 @@ struct StringMinMaxBase : public MinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
@@ -82448,7 +82459,7 @@ struct VectorMinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Update(Vector inputs[], FunctionData *, idx_t input_count, Vector &state_vector, idx_t count) {
+	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
 		auto &input = inputs[0];
 		VectorData idata;
 		input.Orrify(count, idata);
@@ -82473,7 +82484,7 @@ struct VectorMinMaxBase {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.value) {
 			return;
 		} else if (!target->value) {
@@ -82484,7 +82495,7 @@ struct VectorMinMaxBase {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->value) {
 			// we need to use SetNull here
 			// since for STRUCT columns only setting the validity mask of the struct is incorrect
@@ -82618,13 +82629,13 @@ struct ProductFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		target->val *= source.val;
 		target->empty = target->empty && source.empty;
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->empty) {
 			mask.SetInvalid(idx);
 			return;
@@ -82632,7 +82643,7 @@ struct ProductFunction {
 		target[idx] = state->val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (state->empty) {
 			state->empty = false;
 		}
@@ -82640,10 +82651,10 @@ struct ProductFunction {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
@@ -82689,15 +82700,15 @@ struct SkewnessOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->n++;
 		state->sum += data[idx];
 		state->sum_sqr += pow(data[idx], 2);
@@ -82705,7 +82716,7 @@ struct SkewnessOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.n == 0) {
 			return;
 		}
@@ -82717,7 +82728,7 @@ struct SkewnessOperation {
 	}
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
 	                     idx_t idx) {
 		if (state->n <= 2) {
 			mask.SetInvalid(idx);
@@ -82792,7 +82803,7 @@ struct StringAggFunction {
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->dataptr) {
 			mask.SetInvalid(idx);
 		} else {
@@ -82847,26 +82858,26 @@ struct StringAggFunction {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *str_data, ValidityMask &str_mask,
-	                      idx_t str_idx) {
-		PerformOperation(state, str_data[str_idx], bind_data);
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *str_data,
+	                      ValidityMask &str_mask, idx_t str_idx) {
+		PerformOperation(state, str_data[str_idx], aggr_input_data.bind_data);
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
 		if (!source.dataptr) {
 			// source is not set: skip combining
 			return;
 		}
-		PerformOperation(target, string_t(source.dataptr, source.size), bind_data);
+		PerformOperation(target, string_t(source.dataptr, source.size), aggr_input_data.bind_data);
 	}
 };
@@ -82929,7 +82940,7 @@ struct SumSetOperation {
 		state->Initialize();
 	}
 	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		target->Combine(source);
 	}
 	template <class STATE>
@@ -82940,7 +82951,7 @@ struct SumSetOperation {
 struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
@@ -82951,7 +82962,7 @@ struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
@@ -82963,7 +82974,7 @@ struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, HugeintA
 template <class ADD_OPERATOR>
 struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATOR> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
@@ -82980,7 +82991,7 @@ using KahanSumOperation = DoubleSumOperation<KahanAdd>;
 struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
@@ -83890,15 +83901,15 @@ struct ApproxQuantileOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
@@ -83908,7 +83919,7 @@ struct ApproxQuantileOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.pos == 0) {
 			return;
 		}
@@ -83935,7 +83946,7 @@ struct ApproxQuantileOperation {
 struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data_p, STATE *state, TARGET_TYPE *target,
+	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, TARGET_TYPE *target,
 	                     ValidityMask &mask, idx_t idx) {
 		if (state->pos == 0) {
@@ -83943,9 +83954,9 @@ struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
 			return;
 		}
 		D_ASSERT(state->h);
-		D_ASSERT(bind_data_p);
+		D_ASSERT(aggr_input_data.bind_data);
 		state->h->compress();
-		auto bind_data = (ApproximateQuantileBindData *)bind_data_p;
+		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
 		D_ASSERT(bind_data->quantiles.size() == 1);
 		target[idx] = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state->h->quantile(bind_data->quantiles[0]));
 	}
@@ -84028,15 +84039,15 @@ template <class CHILD_TYPE>
 struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
+	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);
 			return;
 		}
-		D_ASSERT(bind_data_p);
-		auto bind_data = (ApproximateQuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
@@ -84058,12 +84069,12 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 	}
 	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, FunctionData *bind_data_p, Vector &result, idx_t count, // NOLINT
+	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(bind_data_p);
-		auto bind_data = (ApproximateQuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
 		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -84072,7 +84083,7 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 			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, bind_data, sdata[0], rdata, mask, 0);
+			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);
@@ -84082,7 +84093,7 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 			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, bind_data, sdata[i], rdata, mask, i + offset);
+				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
 			}
 		}
@@ -84323,7 +84334,7 @@ struct ModeFunction {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->frequency_map) {
 			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
 		}
@@ -84332,7 +84343,7 @@ struct ModeFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (!source.frequency_map) {
 			return;
 		}
@@ -84347,7 +84358,7 @@ struct ModeFunction {
 	}
 	template <class INPUT_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, INPUT_TYPE *target, ValidityMask &mask,
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, INPUT_TYPE *target, ValidityMask &mask,
 	                     idx_t idx) {
 		if (!state->frequency_map) {
 			mask.SetInvalid(idx);
@@ -84361,7 +84372,7 @@ struct ModeFunction {
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
 	                              idx_t count) {
 		if (!state->frequency_map) {
 			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
@@ -84372,7 +84383,7 @@ struct ModeFunction {
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   AggregateInputData &, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
 	                   Vector &result, idx_t rid, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
@@ -84981,20 +84992,20 @@ struct QuantileOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data_p, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->v.emplace_back(data[idx]);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.v.empty()) {
 			return;
 		}
@@ -85012,12 +85023,13 @@ struct QuantileOperation {
 };
 template <class STATE_TYPE, class RESULT_TYPE, class OP>
-static void ExecuteListFinalize(Vector &states, FunctionData *bind_data_p, Vector &result, idx_t count, // NOLINT
+static void ExecuteListFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result,
+                                idx_t count, // NOLINT
                                 idx_t offset) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-	D_ASSERT(bind_data_p);
-	auto bind_data = (QuantileBindData *)bind_data_p;
+	D_ASSERT(aggr_input_data.bind_data);
+	auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
 	if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -85026,7 +85038,7 @@ static void ExecuteListFinalize(Vector &states, FunctionData *bind_data_p, Vecto
 		auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 		auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
 		auto &mask = ConstantVector::Validity(result);
-		OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, bind_data, sdata[0], rdata, mask, 0);
+		OP::template 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);
@@ -85036,7 +85048,7 @@ static void ExecuteListFinalize(Vector &states, FunctionData *bind_data_p, Vecto
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &mask = FlatVector::Validity(result);
 		for (idx_t i = 0; i < count; i++) {
-			OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, bind_data, sdata[i], rdata, mask, i + offset);
+			OP::template Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
 		}
 	}
@@ -85057,14 +85069,14 @@ template <bool DISCRETE>
 struct QuantileScalarOperation : public QuantileOperation {
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
+	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
 	                     ValidityMask &mask, idx_t idx) {
 		if (state->v.empty()) {
 			mask.SetInvalid(idx);
 			return;
 		}
-		D_ASSERT(bind_data_p);
-		auto bind_data = (QuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
 		D_ASSERT(bind_data->quantiles.size() == 1);
 		Interpolator<DISCRETE> interp(bind_data->quantiles[0], state->v.size());
 		target[idx] = interp.template Operation<typename STATE::SaveType, RESULT_TYPE>(state->v.data(), result);
@@ -85072,8 +85084,8 @@ struct QuantileScalarOperation : public QuantileOperation {
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
-	                   Vector &result, idx_t ridx, idx_t bias) {
+	                   AggregateInputData &aggr_input_data, STATE *state, const FrameBounds &frame,
+	                   const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
@@ -85086,8 +85098,8 @@ struct QuantileScalarOperation : public QuantileOperation {
 		auto index = state->w.data();
 		D_ASSERT(index);
-		D_ASSERT(bind_data_p);
-		auto bind_data = (QuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
 		// Find the two positions needed
 		const auto q = bind_data->quantiles[0];
@@ -85189,15 +85201,15 @@ template <class CHILD_TYPE, bool DISCRETE>
 struct QuantileListOperation : public QuantileOperation {
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
+	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
 	                     ValidityMask &mask, idx_t idx) {
 		if (state->v.empty()) {
 			mask.SetInvalid(idx);
 			return;
 		}
-		D_ASSERT(bind_data_p);
-		auto bind_data = (QuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
@@ -85224,10 +85236,10 @@ struct QuantileListOperation : public QuantileOperation {
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
-	                   Vector &list, idx_t lidx, idx_t bias) {
-		D_ASSERT(bind_data_p);
-		auto bind_data = (QuantileBindData *)bind_data_p;
+	                   AggregateInputData &aggr_input_data, STATE *state, const FrameBounds &frame,
+	                   const FrameBounds &prev, Vector &list, idx_t lidx, idx_t bias) {
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
 		QuantileIncluded included(fmask, dmask, bias);
@@ -85568,8 +85580,8 @@ template <typename MEDIAN_TYPE>
 struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, RESULT_TYPE *target, ValidityMask &mask,
+	                     idx_t idx) {
 		if (state->v.empty()) {
 			mask.SetInvalid(idx);
 			return;
@@ -85584,7 +85596,7 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   FunctionData *bind_data_p, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
+	                   AggregateInputData &, STATE *state, const FrameBounds &frame, const FrameBounds &prev,
 	                   Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
@@ -85976,16 +85988,17 @@ struct ReservoirQuantileOperation {
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data_p, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		auto bind_data = (ReservoirQuantileBindData *)bind_data_p;
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *data, ValidityMask &mask,
+	                      idx_t idx) {
+		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
 		D_ASSERT(bind_data);
 		if (state->pos == 0) {
 			state->Resize(bind_data->sample_size);
@@ -85998,7 +86011,7 @@ struct ReservoirQuantileOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.pos == 0) {
 			return;
 		}
@@ -86032,15 +86045,15 @@ struct ReservoirQuantileOperation {
 struct ReservoirQuantileScalarOperation : public ReservoirQuantileOperation {
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, FunctionData *bind_data_p, STATE *state, TARGET_TYPE *target,
+	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);
 			return;
 		}
 		D_ASSERT(state->v);
-		D_ASSERT(bind_data_p);
-		auto bind_data = (ReservoirQuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
 		auto v_t = state->v;
 		D_ASSERT(bind_data->quantiles.size() == 1);
 		auto offset = (idx_t)((double)(state->pos - 1) * bind_data->quantiles[0]);
@@ -86092,15 +86105,15 @@ template <class CHILD_TYPE>
 struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
+	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);
 			return;
 		}
-		D_ASSERT(bind_data_p);
-		auto bind_data = (ReservoirQuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
@@ -86124,12 +86137,12 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 	}
 	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, FunctionData *bind_data_p, Vector &result, idx_t count, // NOLINT
+	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(bind_data_p);
-		auto bind_data = (ReservoirQuantileBindData *)bind_data_p;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
 		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -86138,7 +86151,7 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 			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, bind_data, sdata[0], rdata, mask, 0);
+			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);
@@ -86148,7 +86161,7 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 			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, bind_data, sdata[i], rdata, mask, i + offset);
+				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
 			}
 		}
@@ -86448,7 +86461,7 @@ struct HistogramFunction {
 };
 template <class OP, class T, class MAP_TYPE>
-static void HistogramUpdateFunction(Vector inputs[], FunctionData *, idx_t input_count, Vector &state_vector,
+static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector,
                                     idx_t count) {
 	D_ASSERT(input_count == 1);
@@ -86463,7 +86476,7 @@ static void HistogramUpdateFunction(Vector inputs[], FunctionData *, idx_t input
 }
 template <class T, class MAP_TYPE>
-static void HistogramCombineFunction(Vector &state, Vector &combined, FunctionData *bind_data, idx_t count) {
+static void HistogramCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
 	VectorData sdata;
 	state.Orrify(count, sdata);
@@ -86488,7 +86501,8 @@ static void HistogramCombineFunction(Vector &state, Vector &combined, FunctionDa
 }
 template <class OP, class T, class MAP_TYPE>
-static void HistogramFinalizeFunction(Vector &state_vector, FunctionData *, Vector &result, idx_t count, idx_t offset) {
+static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
+                                      idx_t offset) {
 	VectorData sdata;
 	state_vector.Orrify(count, sdata);
@@ -86676,7 +86690,8 @@ struct ListFunction {
 	}
 };
-static void ListUpdateFunction(Vector inputs[], FunctionData *, idx_t input_count, Vector &state_vector, idx_t count) {
+static void ListUpdateFunction(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector,
+                               idx_t count) {
 	D_ASSERT(input_count == 1);
 	auto &input = inputs[0];
@@ -86700,7 +86715,7 @@ static void ListUpdateFunction(Vector inputs[], FunctionData *, idx_t input_coun
 	}
 }
-static void ListCombineFunction(Vector &state, Vector &combined, FunctionData *bind_data, idx_t count) {
+static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
 	VectorData sdata;
 	state.Orrify(count, sdata);
 	auto states_ptr = (ListAggState **)sdata.data;
@@ -86723,7 +86738,7 @@ static void ListCombineFunction(Vector &state, Vector &combined, FunctionData *b
 	}
 }
-static void ListFinalize(Vector &state_vector, FunctionData *, Vector &result, idx_t count, idx_t offset) {
+static void ListFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
 	VectorData sdata;
 	state_vector.Orrify(count, sdata);
 	auto states = (ListAggState **)sdata.data;
@@ -86854,13 +86869,13 @@ struct RegrAvgFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	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, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -86873,7 +86888,7 @@ struct RegrAvgFunction {
 };
 struct RegrAvgXFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
+	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++;
@@ -86882,7 +86897,7 @@ struct RegrAvgXFunction : RegrAvgFunction {
 struct RegrAvgYFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
+	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++;
@@ -86932,19 +86947,19 @@ struct RegrCountFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		*target += source;
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		target[idx] = *state;
 	}
 	static bool IgnoreNull() {
 		return true;
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
+	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 += 1;
 	}
@@ -86994,21 +87009,21 @@ struct RegrSlopeOperation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, y_data, x_data, bmask,
-		                                                          amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, bind_data, y_data, bmask, yidx);
+	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, y_data, x_data,
+		                                                          bmask, amask, yidx, xidx);
+		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, bind_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.var_pop, &target->var_pop, aggr_input_data);
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (state->cov_pop.count == 0 || state->var_pop.count == 0) {
 			mask.SetInvalid(idx);
 		} else {
@@ -87052,30 +87067,31 @@ struct RegrInterceptOperation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
+	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, bind_data, x_data, y_data,
-		                                                                  amask, bmask, xidx, yidx);
+		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(&state->slope, aggr_input_data, x_data,
+		                                                                  y_data, amask, bmask, xidx, yidx);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_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, bind_data);
+		RegrSlopeOperation::Combine<RegrSlopeState, OP>(source.slope, &target->slope, aggr_input_data);
 	}
 	template <class T, class STATE>
-	static void Finalize(Vector &result, FunctionData *fd, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	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);
 			return;
 		}
-		RegrSlopeOperation::Finalize<T, RegrSlopeState>(result, fd, &state->slope, target, mask, idx);
+		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;
@@ -87121,23 +87137,26 @@ struct RegrR2Operation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, y_data, x_data, bmask, amask,
-		                                                        yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_x, bind_data, y_data, bmask, yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_y, bind_data, x_data, amask, xidx);
+	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);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		CorrOperation::Combine<CorrState, OP>(source.corr, &target->corr, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, &target->var_pop_x, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, &target->var_pop_y, bind_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, FunctionData *fd, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	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;
 		if (!Value::DoubleIsFinite(var_pop_x)) {
 			throw OutOfRangeException("VARPOP(X) is out of range!");
@@ -87154,7 +87173,7 @@ struct RegrR2Operation {
 			target[idx] = 1;
 			return;
 		}
-		CorrOperation::Finalize<T, CorrState>(result, fd, &state->corr, target, mask, idx);
+		CorrOperation::Finalize<T, CorrState>(result, aggr_input_data, &state->corr, target, mask, idx);
 		target[idx] = pow(target[idx], 2);
 	}
@@ -87216,13 +87235,14 @@ struct RegrBaseOperation {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, bind_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, bind_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, FunctionData *fd, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+	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);
 			return;
@@ -87231,7 +87251,7 @@ struct RegrBaseOperation {
 		if (!Value::DoubleIsFinite(var_pop)) {
 			throw OutOfRangeException("VARPOP is out of range!");
 		}
-		RegrCountFunction::Finalize<T, size_t>(result, fd, &state->count, target, mask, idx);
+		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
 		target[idx] *= var_pop;
 	}
@@ -87242,21 +87262,21 @@ struct RegrBaseOperation {
 struct RegrSXXOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, y_data, x_data, bmask, amask,
-		                                                         yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, bind_data, y_data, bmask, yidx);
+	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);
 	}
 };
 struct RegrSYYOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, y_data, x_data, bmask, amask,
-		                                                         yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, bind_data, x_data, bmask, xidx);
+	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);
 	}
 };
@@ -87297,25 +87317,26 @@ struct RegrSXYOperation {
 	}
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_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, bind_data, y_data, x_data, bmask, amask,
-		                                                         yidx, xidx);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, bind_data, x_data, y_data, amask,
-		                                                          bmask, xidx, yidx);
+	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);
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, bind_data);
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, bind_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, FunctionData *fd, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		CovarPopOperation::Finalize<T, CovarState>(result, fd, &state->cov_pop, target, mask, idx);
+	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, fd, &state->count, target, mask, idx);
+		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
 		target[idx] *= cov_pop;
 	}
@@ -87465,9 +87486,9 @@ struct SortedAggregateFunction {
 		sort_chunk.SetCardinality(count);
 	}
-	static void SimpleUpdate(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
+	static void SimpleUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
 	                         idx_t count) {
-		const auto order_bind = (SortedAggregateBindData *)bind_data;
+		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
 		DataChunk arg_chunk;
 		DataChunk sort_chunk;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_chunk, sort_chunk);
@@ -87477,14 +87498,14 @@ struct SortedAggregateFunction {
 		order_state->ordering.Append(sort_chunk);
 	}
-	static void ScatterUpdate(Vector inputs[], FunctionData *bind_data, idx_t input_count, Vector &states,
+	static void ScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
 	                          idx_t count) {
 		if (!count) {
 			return;
 		}
 		// Append the arguments to the two sub-collections
-		const auto order_bind = (SortedAggregateBindData *)bind_data;
+		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
 		DataChunk arg_inputs;
 		DataChunk sort_inputs;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_inputs, sort_inputs);
@@ -87529,7 +87550,7 @@ struct SortedAggregateFunction {
 	}
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, FunctionData *bind_data) {
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
 		if (source.arguments.Count() == 0) {
 			return;
 		}
@@ -87537,8 +87558,9 @@ struct SortedAggregateFunction {
 		target->ordering.Append(const_cast<ChunkCollection &>(source.ordering));
 	}
-	static void Finalize(Vector &states, FunctionData *bind_data, Vector &result, idx_t count, idx_t offset) {
-		const auto order_bind = (SortedAggregateBindData *)bind_data;
+	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+	                     idx_t offset) {
+		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
 		//	 Reusable inner state
 		vector<data_t> agg_state(order_bind->function.state_size());
@@ -87550,6 +87572,7 @@ struct SortedAggregateFunction {
 		// State variables
 		const auto input_count = order_bind->function.arguments.size();
 		auto bind_info = order_bind->bind_info.get();
+		AggregateInputData aggr_bind_info(bind_info);
 		// Inner aggregate APIs
 		auto initialize = order_bind->function.initialize;
@@ -87574,17 +87597,17 @@ struct SortedAggregateFunction {
 			for (auto &chunk : state->arguments.Chunks()) {
 				// These are all simple updates, so use it if available
 				if (simple_update) {
-					simple_update(chunk->data.data(), bind_info, input_count, agg_state.data(), chunk->size());
+					simple_update(chunk->data.data(), aggr_bind_info, input_count, agg_state.data(), chunk->size());
 				} else {
 					// We are only updating a constant state
 					agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-					update(chunk->data.data(), bind_info, input_count, agg_state_vec, chunk->size());
+					update(chunk->data.data(), aggr_bind_info, input_count, agg_state_vec, chunk->size());
 				}
 			}
 			// Finalize a single value at the next offset
 			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, bind_info, result, 1, i + offset);
+			finalize(agg_state_vec, aggr_bind_info, result, 1, i + offset);
 			if (destructor) {
 				destructor(agg_state_vec, 1);
@@ -95544,6 +95567,7 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (ListAggregatesBindData &)*func_expr.bind_info;
 	auto &aggr = (BoundAggregateExpression &)*info.aggr_expr;
+	AggregateInputData aggr_input_data(aggr.bind_info.get());
 	D_ASSERT(aggr.function.update);
@@ -95601,7 +95625,7 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 				// update the aggregate state(s)
 				Vector slice = Vector(child_vector, sel_vector, states_idx);
-				aggr.function.update(&slice, aggr.bind_info.get(), 1, state_vector_update, states_idx);
+				aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
 				// reset values
 				states_idx = 0;
@@ -95617,12 +95641,12 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	// update the remaining elements of the last list(s)
 	if (states_idx != 0) {
 		Vector slice = Vector(child_vector, sel_vector, states_idx);
-		aggr.function.update(&slice, aggr.bind_info.get(), 1, state_vector_update, states_idx);
+		aggr.function.update(&slice, aggr_input_data, 1, state_vector_update, states_idx);
 	}
 	if (IS_AGGR) {
 		// finalize all the aggregate states
-		aggr.function.finalize(state_vector.state_vector, aggr.bind_info.get(), result, count, 0);
+		aggr.function.finalize(state_vector.state_vector, aggr_input_data, result, count, 0);
 	} else {
 		// finalize manually to use the map
@@ -104752,7 +104776,8 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 		state_vec_ptr[i] = (data_ptr_t)target_ptr;
 	}
-	bind_data.aggr.finalize(local_state.addresses, nullptr, result, input.size(), 0);
+	AggregateInputData aggr_input_data(nullptr);
+	bind_data.aggr.finalize(local_state.addresses, aggr_input_data, result, input.size(), 0);
 	for (idx_t i = 0; i < input.size(); i++) {
 		auto state_idx = state_data.sel->get_index(i);
@@ -104815,7 +104840,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
 		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
-		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, nullptr, 1);
+		AggregateInputData aggr_input_data(nullptr);
+		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
 		result_ptr[i] =
 		    StringVector::AddStringOrBlob(result, (const char *)local_state.state_buffer1.get(), bind_data.state_size);
@@ -104876,10 +104902,10 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	return make_unique<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size());
 }
-static void ExportAggregateFinalize(Vector &state, FunctionData *bind_data_p, Vector &result, idx_t count,
+static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
                                     idx_t offset) {
 	D_ASSERT(offset == 0);
-	auto bind_data = (ExportAggregateFunctionBindData *)bind_data_p;
+	auto bind_data = (ExportAggregateFunctionBindData *)aggr_input_data.bind_data;
 	auto state_size = bind_data->aggregate->function.state_size();
 	auto blob_ptr = FlatVector::GetData<string_t>(result);
 	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(state);