duckdb 0.8.1-dev0.0 → 0.8.1-dev111.0

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

@@ -49,30 +49,28 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 
 struct MinMaxBase {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->isset = false;
+	static void Initialize(STATE &state) {
+		state.isset = false;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &input_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
 	                              idx_t count) {
-		D_ASSERT(mask.RowIsValid(0));
-		if (!state->isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input_data, input[0]);
-			state->isset = true;
+		if (!state.isset) {
+			OP::template Assign<INPUT_TYPE, STATE>(state, input, unary_input.input);
+			state.isset = true;
 		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input_data, input[0]);
+			OP::template Execute<INPUT_TYPE, STATE>(state, input, unary_input.input);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &input_data, INPUT_TYPE *input, ValidityMask &mask,
-	                      idx_t idx) {
-		if (!state->isset) {
-			OP::template Assign<INPUT_TYPE, STATE>(state, input_data, input[idx]);
-			state->isset = true;
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (!state.isset) {
+			OP::template Assign<INPUT_TYPE, STATE>(state, input, unary_input.input);
+			state.isset = true;
 		} else {
-			OP::template Execute<INPUT_TYPE, STATE>(state, input_data, input[idx]);
+			OP::template Execute<INPUT_TYPE, STATE>(state, input, unary_input.input);
 		}
 	}
 
@@ -83,125 +81,128 @@ struct MinMaxBase {
 
 struct NumericMinMaxBase : public MinMaxBase {
 	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, AggregateInputData &, INPUT_TYPE input) {
-		state->value = input;
+	static void Assign(STATE &state, INPUT_TYPE input, AggregateInputData &) {
+		state.value = input;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		mask.Set(idx, state->isset);
-		target[idx] = state->value;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.isset) {
+			finalize_data.ReturnNull();
+		} else {
+			target = state.value;
+		}
 	}
 };
 
 struct MinOperation : public NumericMinMaxBase {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, AggregateInputData &, INPUT_TYPE input) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state->value)) {
-			state->value = input;
+	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &) {
+		if (LessThan::Operation<INPUT_TYPE>(input, state.value)) {
+			state.value = input;
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
 		}
-		if (!target->isset) {
+		if (!target.isset) {
 			// target is NULL, use source value directly
-			*target = source;
-		} else if (GreaterThan::Operation(target->value, source.value)) {
-			target->value = source.value;
+			target = source;
+		} else if (GreaterThan::Operation(target.value, source.value)) {
+			target.value = source.value;
 		}
 	}
 };
 
 struct MaxOperation : public NumericMinMaxBase {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, AggregateInputData &, INPUT_TYPE input) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state->value)) {
-			state->value = input;
+	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &) {
+		if (GreaterThan::Operation<INPUT_TYPE>(input, state.value)) {
+			state.value = input;
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
 		}
-		if (!target->isset) {
+		if (!target.isset) {
 			// target is NULL, use source value directly
-			*target = source;
-		} else if (LessThan::Operation(target->value, source.value)) {
-			target->value = source.value;
+			target = source;
+		} else if (LessThan::Operation(target.value, source.value)) {
+			target.value = source.value;
 		}
 	}
 };
 
 struct StringMinMaxBase : public MinMaxBase {
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->isset && !state->value.IsInlined()) {
-			delete[] state->value.GetData();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.isset && !state.value.IsInlined()) {
+			delete[] state.value.GetData();
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, AggregateInputData &input_data, INPUT_TYPE input) {
-		Destroy(input_data, state);
+	static void Assign(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
+		Destroy(state, input_data);
 		if (input.IsInlined()) {
-			state->value = input;
+			state.value = input;
 		} else {
 			// non-inlined string, need to allocate space for it
 			auto len = input.GetSize();
 			auto ptr = new char[len];
 			memcpy(ptr, input.GetData(), len);
 
-			state->value = string_t(ptr, len);
+			state.value = string_t(ptr, len);
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->isset) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.isset) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->value);
+			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &input_data) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
 		if (!source.isset) {
 			// source is NULL, nothing to do
 			return;
 		}
-		if (!target->isset) {
+		if (!target.isset) {
 			// target is NULL, use source value directly
-			Assign(target, input_data, source.value);
-			target->isset = true;
+			Assign(target, source.value, input_data);
+			target.isset = true;
 		} else {
-			OP::template Execute<string_t, STATE>(target, input_data, source.value);
+			OP::template Execute<string_t, STATE>(target, source.value, input_data);
 		}
 	}
 };
 
 struct MinOperationString : public StringMinMaxBase {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, AggregateInputData &input_data, INPUT_TYPE input) {
-		if (LessThan::Operation<INPUT_TYPE>(input, state->value)) {
-			Assign(state, input_data, input);
+	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
+		if (LessThan::Operation<INPUT_TYPE>(input, state.value)) {
+			Assign(state, input, input_data);
 		}
 	}
 };
 
 struct MaxOperationString : public StringMinMaxBase {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, AggregateInputData &input_data, INPUT_TYPE input) {
-		if (GreaterThan::Operation<INPUT_TYPE>(input, state->value)) {
-			Assign(state, input_data, input);
+	static void Execute(STATE &state, INPUT_TYPE input, AggregateInputData &input_data) {
+		if (GreaterThan::Operation<INPUT_TYPE>(input, state.value)) {
+			Assign(state, input, input_data);
 		}
 	}
 };
@@ -215,8 +216,8 @@ static bool TemplatedOptimumType(Vector &left, idx_t lidx, idx_t lcount, Vector
 	lidx = lvdata.sel->get_index(lidx);
 	ridx = rvdata.sel->get_index(ridx);
 
-	auto ldata = (const T *)lvdata.data;
-	auto rdata = (const T *)rvdata.data;
+	auto ldata = UnifiedVectorFormat::GetData<T>(lvdata);
+	auto rdata = UnifiedVectorFormat::GetData<T>(rvdata);
 
 	auto &lval = ldata[lidx];
 	auto &rval = rdata[ridx];
@@ -341,8 +342,8 @@ static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector
 	auto &lchild = ListVector::GetEntry(left);
 	auto &rchild = ListVector::GetEntry(right);
 
-	auto ldata = (const list_entry_t *)lvdata.data;
-	auto rdata = (const list_entry_t *)rvdata.data;
+	auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(lvdata);
+	auto rdata = UnifiedVectorFormat::GetData<list_entry_t>(rvdata);
 
 	auto &lval = ldata[lidx];
 	auto &rval = rdata[ridx];
@@ -379,31 +380,31 @@ struct VectorMinMaxBase {
 	}
 
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->value = nullptr;
+	static void Initialize(STATE &state) {
+		state.value = nullptr;
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->value) {
-			delete state->value;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.value) {
+			delete state.value;
 		}
-		state->value = nullptr;
+		state.value = nullptr;
 	}
 
 	template <class STATE>
-	static void Assign(STATE *state, Vector &input, const idx_t idx) {
-		if (!state->value) {
-			state->value = new Vector(input.GetType());
-			state->value->SetVectorType(VectorType::CONSTANT_VECTOR);
+	static void Assign(STATE &state, Vector &input, const idx_t idx) {
+		if (!state.value) {
+			state.value = new Vector(input.GetType());
+			state.value->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
 		sel_t selv = idx;
 		SelectionVector sel(&selv);
-		VectorOperations::Copy(input, *state->value, sel, 1, 0, 0);
+		VectorOperations::Copy(input, *state.value, sel, 1, 0, 0);
 	}
 
 	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
+	static void Execute(STATE &state, Vector &input, const idx_t idx, const idx_t count) {
 		Assign(state, input, idx);
 	}
 
@@ -423,8 +424,8 @@ struct VectorMinMaxBase {
 				continue;
 			}
 			const auto sidx = sdata.sel->get_index(i);
-			auto state = states[sidx];
-			if (!state->value) {
+			auto &state = *states[sidx];
+			if (!state.value) {
 				Assign(state, input, i);
 			} else {
 				OP::template Execute(state, input, i, count);
@@ -433,34 +434,22 @@ struct VectorMinMaxBase {
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (!source.value) {
 			return;
-		} else if (!target->value) {
+		} else if (!target.value) {
 			Assign(target, *source.value, 0);
 		} else {
 			OP::template Execute(target, *source.value, 0, 1);
 		}
 	}
 
-	template <class T, class STATE>
-	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
-			// as for a struct column, we need to also set ALL child columns to NULL
-			switch (result.GetVectorType()) {
-			case VectorType::FLAT_VECTOR:
-				FlatVector::SetNull(result, idx, true);
-				break;
-			case VectorType::CONSTANT_VECTOR:
-				ConstantVector::SetNull(result, true);
-				break;
-			default:
-				throw InternalException("Invalid result vector type for nested min/max");
-			}
+	template <class STATE>
+	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
+		if (!state.value) {
+			finalize_data.ReturnNull();
 		} else {
-			VectorOperations::Copy(*state->value, result, 1, 0, idx);
+			VectorOperations::Copy(*state.value, finalize_data.result, 1, 0, finalize_data.result_idx);
 		}
 	}
 
@@ -474,8 +463,8 @@ struct VectorMinMaxBase {
 
 struct MinOperationVector : public VectorMinMaxBase {
 	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
-		if (TemplatedOptimumValue<DistinctLessThan>(input, idx, count, *state->value, 0, 1)) {
+	static void Execute(STATE &state, Vector &input, const idx_t idx, const idx_t count) {
+		if (TemplatedOptimumValue<DistinctLessThan>(input, idx, count, *state.value, 0, 1)) {
 			Assign(state, input, idx);
 		}
 	}
@@ -483,8 +472,8 @@ struct MinOperationVector : public VectorMinMaxBase {
 
 struct MaxOperationVector : public VectorMinMaxBase {
 	template <class STATE>
-	static void Execute(STATE *state, Vector &input, const idx_t idx, const idx_t count) {
-		if (TemplatedOptimumValue<DistinctGreaterThan>(input, idx, count, *state->value, 0, 1)) {
+	static void Execute(STATE &state, Vector &input, const idx_t idx, const idx_t count) {
+		if (TemplatedOptimumValue<DistinctGreaterThan>(input, idx, count, *state.value, 0, 1)) {
 			Assign(state, input, idx);
 		}
 	}
@@ -518,11 +507,10 @@ unique_ptr<FunctionData> BindDecimalMinMax(ClientContext &context, AggregateFunc
 
 template <typename OP, typename STATE>
 static AggregateFunction GetMinMaxFunction(const LogicalType &type) {
-	return AggregateFunction({type}, type, AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE, OP>,
-	                         AggregateFunction::StateCombine<STATE, OP>,
-	                         AggregateFunction::StateFinalize<STATE, void, OP>, nullptr, OP::Bind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
+	return AggregateFunction(
+	    {type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
+	    OP::template Update<STATE, OP>, AggregateFunction::StateCombine<STATE, OP>,
+	    AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind, AggregateFunction::StateDestroy<STATE, OP>);
 }
 
 template <class OP, class OP_STRING, class OP_VECTOR>

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

@@ -13,38 +13,38 @@ struct ProductState {
 
 struct ProductFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = 1;
-		state->empty = true;
+	static void Initialize(STATE &state) {
+		state.val = 1;
+		state.empty = true;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val *= source.val;
-		target->empty = target->empty && source.empty;
+	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, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.empty) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		target[idx] = state->val;
+		target = state.val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (state->empty) {
-			state->empty = false;
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (state.empty) {
+			state.empty = false;
 		}
-		state->val *= input[idx];
+		state.val *= input;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 

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

@@ -15,62 +15,60 @@ struct SkewState {
 
 struct SkewnessOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->n = 0;
-		state->sum = state->sum_sqr = state->sum_cub = 0;
+	static void Initialize(STATE &state) {
+		state.n = 0;
+		state.sum = state.sum_sqr = state.sum_cub = 0;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		state->n++;
-		state->sum += data[idx];
-		state->sum_sqr += pow(data[idx], 2);
-		state->sum_cub += pow(data[idx], 3);
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		state.n++;
+		state.sum += input;
+		state.sum_sqr += pow(input, 2);
+		state.sum_cub += pow(input, 3);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (source.n == 0) {
 			return;
 		}
 
-		target->n += source.n;
-		target->sum += source.sum;
-		target->sum_sqr += source.sum_sqr;
-		target->sum_cub += source.sum_cub;
+		target.n += source.n;
+		target.sum += source.sum;
+		target.sum_sqr += source.sum_sqr;
+		target.sum_cub += source.sum_cub;
 	}
 
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		if (state->n <= 2) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
+		if (state.n <= 2) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		double n = state->n;
+		double n = state.n;
 		double temp = 1 / n;
-		auto p = std::pow(temp * (state->sum_sqr - state->sum * state->sum * temp), 3);
+		auto p = std::pow(temp * (state.sum_sqr - state.sum * state.sum * temp), 3);
 		if (p < 0) {
 			p = 0; // Shouldn't be below 0 but floating points are weird
 		}
 		double div = std::sqrt(p);
 		if (div == 0) {
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 			return;
 		}
 		double temp1 = std::sqrt(n * (n - 1)) / (n - 2);
-		target[idx] = temp1 * temp *
-		              (state->sum_cub - 3 * state->sum_sqr * state->sum * temp + 2 * pow(state->sum, 3) * temp * temp) /
-		              div;
-		if (!Value::DoubleIsFinite(target[idx])) {
+		target = temp1 * temp *
+		         (state.sum_cub - 3 * state.sum_sqr * state.sum * temp + 2 * pow(state.sum, 3) * temp * temp) / div;
+		if (!Value::DoubleIsFinite(target)) {
 			throw OutOfRangeException("SKEW is out of range!");
 		}
 	}

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

@@ -32,25 +32,25 @@ struct StringAggBindData : public FunctionData {
 
 struct StringAggFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->dataptr = nullptr;
-		state->alloc_size = 0;
-		state->size = 0;
+	static void Initialize(STATE &state) {
+		state.dataptr = nullptr;
+		state.alloc_size = 0;
+		state.size = 0;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->dataptr) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.dataptr) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = StringVector::AddString(result, state->dataptr, state->size);
+			target = StringVector::AddString(finalize_data.result, state.dataptr, state.size);
 		}
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->dataptr) {
-			delete[] state->dataptr;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.dataptr) {
+			delete[] state.dataptr;
 		}
 	}
 
@@ -58,57 +58,56 @@ struct StringAggFunction {
 		return true;
 	}
 
-	static inline void PerformOperation(StringAggState *state, const char *str, const char *sep, idx_t str_size,
+	static inline void PerformOperation(StringAggState &state, const char *str, const char *sep, idx_t str_size,
 	                                    idx_t sep_size) {
-		if (!state->dataptr) {
+		if (!state.dataptr) {
 			// first iteration: allocate space for the string and copy it into the state
-			state->alloc_size = MaxValue<idx_t>(8, NextPowerOfTwo(str_size));
-			state->dataptr = new char[state->alloc_size];
-			state->size = str_size;
-			memcpy(state->dataptr, str, str_size);
+			state.alloc_size = MaxValue<idx_t>(8, NextPowerOfTwo(str_size));
+			state.dataptr = new char[state.alloc_size];
+			state.size = str_size;
+			memcpy(state.dataptr, str, str_size);
 		} else {
 			// subsequent iteration: first check if we have space to place the string and separator
-			idx_t required_size = state->size + str_size + sep_size;
-			if (required_size > state->alloc_size) {
+			idx_t required_size = state.size + str_size + sep_size;
+			if (required_size > state.alloc_size) {
 				// no space! allocate extra space
-				while (state->alloc_size < required_size) {
-					state->alloc_size *= 2;
+				while (state.alloc_size < required_size) {
+					state.alloc_size *= 2;
 				}
-				auto new_data = new char[state->alloc_size];
-				memcpy(new_data, state->dataptr, state->size);
-				delete[] state->dataptr;
-				state->dataptr = new_data;
+				auto new_data = new char[state.alloc_size];
+				memcpy(new_data, state.dataptr, state.size);
+				delete[] state.dataptr;
+				state.dataptr = new_data;
 			}
 			// copy the separator
-			memcpy(state->dataptr + state->size, sep, sep_size);
-			state->size += sep_size;
+			memcpy(state.dataptr + state.size, sep, sep_size);
+			state.size += sep_size;
 			// copy the string
-			memcpy(state->dataptr + state->size, str, str_size);
-			state->size += str_size;
+			memcpy(state.dataptr + state.size, str, str_size);
+			state.size += str_size;
 		}
 	}
 
-	static inline void PerformOperation(StringAggState *state, string_t str, FunctionData *data_p) {
+	static inline void PerformOperation(StringAggState &state, string_t str, optional_ptr<FunctionData> data_p) {
 		auto &data = data_p->Cast<StringAggBindData>();
 		PerformOperation(state, str.GetData(), data.sep.c_str(), str.GetSize(), data.sep.size());
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	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);
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		PerformOperation(state, input, unary_input.input.bind_data);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
 		if (!source.dataptr) {
 			// source is not set: skip combining
 			return;