duckdb 0.8.1-dev96.0 → 0.8.1

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

@@ -42,53 +42,53 @@ static AggregateFunction GetBitfieldUnaryAggregate(LogicalType type) {
 
 struct BitwiseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
+	static void Initialize(STATE &state) {
 		//  If there are no matching rows, returns a null value.
-		state->is_set = false;
+		state.is_set = false;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			OP::template Assign(state, input[idx]);
-			state->is_set = true;
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
+		if (!state.is_set) {
+			OP::template Assign(state, input);
+			state.is_set = true;
 		} else {
-			OP::template Execute(state, input[idx]);
+			OP::template Execute(state, input);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
+		OP::template Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 	}
 
 	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, INPUT_TYPE input) {
-		state->value = input;
+	static void Assign(STATE &state, INPUT_TYPE input) {
+		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.is_set) {
 			// source is NULL, nothing to do.
 			return;
 		}
-		if (!target->is_set) {
+		if (!target.is_set) {
 			// target is NULL, use source value directly.
 			OP::template Assign(target, source.value);
-			target->is_set = true;
+			target.is_set = true;
 		} else {
 			OP::template Execute(target, source.value);
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->value;
+			target = state.value;
 		}
 	}
 
@@ -99,61 +99,61 @@ struct BitwiseOperation {
 
 struct BitAndOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		state->value &= input;
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		state.value &= input;
 	}
 };
 
 struct BitOrOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		state->value |= input;
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		state.value |= input;
 	}
 };
 
 struct BitXorOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		state->value ^= input;
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		state.value ^= input;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 };
 
 struct BitStringBitwiseOperation : public BitwiseOperation {
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->is_set && !state->value.IsInlined()) {
-			delete[] state->value.GetData();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.is_set && !state.value.IsInlined()) {
+			delete[] state.value.GetData();
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, INPUT_TYPE input) {
-		D_ASSERT(state->is_set == false);
+	static void Assign(STATE &state, INPUT_TYPE input) {
+		D_ASSERT(state.is_set == false);
 		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->is_set) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->value);
+			target = finalize_data.ReturnString(state.value);
 		}
 	}
 };
@@ -161,30 +161,30 @@ struct BitStringBitwiseOperation : public BitwiseOperation {
 struct BitStringAndOperation : public BitStringBitwiseOperation {
 
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		Bit::BitwiseAnd(input, state->value, state->value);
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		Bit::BitwiseAnd(input, state.value, state.value);
 	}
 };
 
 struct BitStringOrOperation : public BitStringBitwiseOperation {
 
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		Bit::BitwiseOr(input, state->value, state->value);
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		Bit::BitwiseOr(input, state.value, state.value);
 	}
 };
 
 struct BitStringXorOperation : public BitStringBitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input) {
-		Bit::BitwiseXor(input, state->value, state->value);
+	static void Execute(STATE &state, INPUT_TYPE input) {
+		Bit::BitwiseXor(input, state.value, state.value);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 };

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

@@ -48,49 +48,48 @@ struct BitStringAggOperation {
 	static constexpr const idx_t MAX_BIT_RANGE = 1000000000; // for now capped at 1 billion bits
 
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->is_set = false;
+	static void Initialize(STATE &state) {
+		state.is_set = false;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &data, const INPUT_TYPE *input, ValidityMask &mask,
-	                      idx_t idx) {
-		auto &bind_agg_data = data.bind_data->template Cast<BitstringAggBindData>();
-		if (!state->is_set) {
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		auto &bind_agg_data = unary_input.input.bind_data->template Cast<BitstringAggBindData>();
+		if (!state.is_set) {
 			if (bind_agg_data.min.IsNull() || bind_agg_data.max.IsNull()) {
 				throw BinderException(
 				    "Could not retrieve required statistics. Alternatively, try by providing the statistics "
 				    "explicitly: BITSTRING_AGG(col, min, max) ");
 			}
-			state->min = bind_agg_data.min.GetValue<INPUT_TYPE>();
-			state->max = bind_agg_data.max.GetValue<INPUT_TYPE>();
+			state.min = bind_agg_data.min.GetValue<INPUT_TYPE>();
+			state.max = bind_agg_data.max.GetValue<INPUT_TYPE>();
 			idx_t bit_range =
 			    GetRange(bind_agg_data.min.GetValue<INPUT_TYPE>(), bind_agg_data.max.GetValue<INPUT_TYPE>());
 			if (bit_range > MAX_BIT_RANGE) {
 				throw OutOfRangeException(
 				    "The range between min and max value (%s <-> %s) is too large for bitstring aggregation",
-				    NumericHelper::ToString(state->min), NumericHelper::ToString(state->max));
+				    NumericHelper::ToString(state.min), NumericHelper::ToString(state.max));
 			}
 			idx_t len = Bit::ComputeBitstringLen(bit_range);
 			auto target = len > string_t::INLINE_LENGTH ? string_t(new char[len], len) : string_t(len);
 			Bit::SetEmptyBitString(target, bit_range);
 
-			state->value = target;
-			state->is_set = true;
+			state.value = target;
+			state.is_set = true;
 		}
-		if (input[idx] >= state->min && input[idx] <= state->max) {
-			Execute(state, input[idx], bind_agg_data.min.GetValue<INPUT_TYPE>());
+		if (input >= state.min && input <= state.max) {
+			Execute(state, input, bind_agg_data.min.GetValue<INPUT_TYPE>());
 		} else {
 			throw OutOfRangeException("Value %s is outside of provided min and max range (%s <-> %s)",
-			                          NumericHelper::ToString(input[idx]), NumericHelper::ToString(state->min),
-			                          NumericHelper::ToString(state->max));
+			                          NumericHelper::ToString(input), NumericHelper::ToString(state.min),
+			                          NumericHelper::ToString(state.max));
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
-		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
+		OP::template Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 	}
 
 	template <class INPUT_TYPE>
@@ -108,51 +107,51 @@ struct BitStringAggOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE>
-	static void Execute(STATE *state, INPUT_TYPE input, INPUT_TYPE min) {
-		Bit::SetBit(state->value, input - min, 1);
+	static void Execute(STATE &state, INPUT_TYPE input, INPUT_TYPE min) {
+		Bit::SetBit(state.value, input - min, 1);
 	}
 
 	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.is_set) {
 			return;
 		}
-		if (!target->is_set) {
+		if (!target.is_set) {
 			Assign(target, source.value);
-			target->is_set = true;
-			target->min = source.min;
-			target->max = source.max;
+			target.is_set = true;
+			target.min = source.min;
+			target.max = source.max;
 		} else {
-			Bit::BitwiseOr(source.value, target->value, target->value);
+			Bit::BitwiseOr(source.value, target.value, target.value);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE>
-	static void Assign(STATE *state, INPUT_TYPE input) {
-		D_ASSERT(state->is_set == false);
+	static void Assign(STATE &state, INPUT_TYPE input) {
+		D_ASSERT(state.is_set == false);
 		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->is_set) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->value);
+			target = StringVector::AddStringOrBlob(finalize_data.result, state.value);
 		}
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->is_set && !state->value.IsInlined()) {
-			delete[] state->value.GetData();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.is_set && !state.value.IsInlined()) {
+			delete[] state.value.GetData();
 		}
 	}
 
@@ -162,10 +161,10 @@ struct BitStringAggOperation {
 };
 
 template <>
-void BitStringAggOperation::Execute(BitAggState<hugeint_t> *state, hugeint_t input, hugeint_t min) {
+void BitStringAggOperation::Execute(BitAggState<hugeint_t> &state, hugeint_t input, hugeint_t min) {
 	idx_t val;
 	if (Hugeint::TryCast(input - min, val)) {
-		Bit::SetBit(state->value, val, 1);
+		Bit::SetBit(state.value, val, 1);
 	} else {
 		throw OutOfRangeException("Range too large for bitstring aggregation");
 	}
@@ -200,7 +199,7 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() == 3) {
-		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+		if (!arguments[1]->IsFoldable() || !arguments[2]->IsFoldable()) {
 			throw BinderException("bitstring_agg requires a constant min and max argument");
 		}
 		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);

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

@@ -13,37 +13,37 @@ struct BoolState {
 
 struct BoolAndFunFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = true;
-		state->empty = true;
+	static void Initialize(STATE &state) {
+		state.val = true;
+		state.empty = true;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val = target->val && source.val;
-		target->empty = target->empty && source.empty;
+	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, 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 &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		state->empty = false;
-		state->val = input[idx] && state->val;
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		state.empty = false;
+		state.val = input && state.val;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 	static bool IgnoreNull() {
@@ -53,36 +53,36 @@ struct BoolAndFunFunction {
 
 struct BoolOrFunFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->val = false;
-		state->empty = true;
+	static void Initialize(STATE &state) {
+		state.val = false;
+		state.empty = true;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->val = target->val || source.val;
-		target->empty = target->empty && source.empty;
+	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, 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 &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		state->empty = false;
-		state->val = input[idx] || state->val;
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		state.empty = false;
+		state.val = input || state.val;
 	}
 
 	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/entropy.cpp

@@ -27,38 +27,38 @@ struct EntropyState {
 
 struct EntropyFunctionBase {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->distinct = nullptr;
-		state->count = 0;
+	static void Initialize(STATE &state) {
+		state.distinct = nullptr;
+		state.count = 0;
 	}
 
 	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.distinct) {
 			return;
 		}
-		if (!target->distinct) {
-			target->Assign(source);
+		if (!target.distinct) {
+			target.Assign(source);
 			return;
 		}
 		for (auto &val : *source.distinct) {
 			auto value = val.first;
-			(*target->distinct)[value] += val.second;
+			(*target.distinct)[value] += val.second;
 		}
-		target->count += source.count;
+		target.count += source.count;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		double count = state->count;
-		if (state->distinct) {
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		double count = state.count;
+		if (state.distinct) {
 			double entropy = 0;
-			for (auto &val : *state->distinct) {
+			for (auto &val : *state.distinct) {
 				entropy += (val.second / count) * log2(count / val.second);
 			}
-			target[idx] = entropy;
+			target = entropy;
 		} else {
-			target[idx] = 0;
+			target = 0;
 		}
 	}
 
@@ -66,47 +66,47 @@ struct EntropyFunctionBase {
 		return true;
 	}
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->distinct) {
-			delete state->distinct;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.distinct) {
+			delete state.distinct;
 		}
 	}
 };
 
 struct EntropyFunction : EntropyFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->distinct) {
-			state->distinct = new unordered_map<INPUT_TYPE, idx_t>();
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (!state.distinct) {
+			state.distinct = new unordered_map<INPUT_TYPE, idx_t>();
 		}
-		(*state->distinct)[input[idx]]++;
-		state->count++;
+		(*state.distinct)[input]++;
+		state.count++;
 	}
 	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);
 		}
 	}
 };
 
 struct EntropyFunctionString : EntropyFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->distinct) {
-			state->distinct = new unordered_map<string, idx_t>();
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (!state.distinct) {
+			state.distinct = new unordered_map<string, idx_t>();
 		}
-		auto value = input[idx].GetString();
-		(*state->distinct)[value]++;
-		state->count++;
+		auto value = input.GetString();
+		(*state.distinct)[value]++;
+		state.count++;
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
-	                              ValidityMask &mask, idx_t count) {
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
+			Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 		}
 	}
 };