duckdb 0.8.1-dev26.0 → 0.8.1-dev276.0

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

@@ -8,37 +8,37 @@ namespace duckdb {
 
 struct SumSetOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
+	static void Initialize(STATE &state) {
+		state.Initialize();
 	}
 	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->Combine(source);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target.Combine(source);
 	}
 	template <class STATE>
-	static void AddValues(STATE *state, idx_t count) {
-		state->isset = true;
+	static void AddValues(STATE &state, idx_t count) {
+		state.isset = true;
 	}
 };
 
 struct IntegerSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
 	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] = Hugeint::Convert(state->value);
+			target = Hugeint::Convert(state.value);
 		}
 	}
 };
 
 struct SumToHugeintOperation : public BaseSumOperation<SumSetOperation, HugeintAdd> {
 	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] = state->value;
+			target = state.value;
 		}
 	}
 };
@@ -46,11 +46,11 @@ 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, 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] = state->value;
+			target = state.value;
 		}
 	}
 };
@@ -60,11 +60,11 @@ using KahanSumOperation = DoubleSumOperation<KahanAdd>;
 
 struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd> {
 	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] = state->value;
+			target = state.value;
 		}
 	}
 };

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

@@ -38,8 +38,8 @@ struct ApproximateQuantileBindData : public FunctionData {
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto bind_data = (ApproximateQuantileBindData *)bind_data_p;
-		writer.WriteList<float>(bind_data->quantiles);
+		auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
+		writer.WriteList<float>(bind_data.quantiles);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
@@ -55,49 +55,49 @@ struct ApproxQuantileOperation {
 	using SAVE_TYPE = duckdb_tdigest::Value;
 
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->pos = 0;
-		state->h = nullptr;
+	static void Initialize(STATE &state) {
+		state.pos = 0;
+		state.h = nullptr;
 	}
 
 	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) {
-		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(input);
 		if (!Value::DoubleIsFinite(val)) {
 			return;
 		}
-		if (!state->h) {
-			state->h = new duckdb_tdigest::TDigest(100);
+		if (!state.h) {
+			state.h = new duckdb_tdigest::TDigest(100);
 		}
-		state->h->add(val);
-		state->pos++;
+		state.h->add(val);
+		state.pos++;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
 		if (source.pos == 0) {
 			return;
 		}
 		D_ASSERT(source.h);
-		if (!target->h) {
-			target->h = new duckdb_tdigest::TDigest(100);
+		if (!target.h) {
+			target.h = new duckdb_tdigest::TDigest(100);
 		}
-		target->h->merge(source.h);
-		target->pos += source.pos;
+		target.h->merge(source.h);
+		target.pos += source.pos;
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		if (state->h) {
-			delete state->h;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.h) {
+			delete state.h;
 		}
 	}
 
@@ -107,21 +107,18 @@ struct ApproxQuantileOperation {
 };
 
 struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
-
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, TARGET_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
+		if (state.pos == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		D_ASSERT(state->h);
-		D_ASSERT(aggr_input_data.bind_data);
-		state->h->compress();
-		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]));
+		D_ASSERT(state.h);
+		D_ASSERT(finalize_data.input.bind_data);
+		state.h->compress();
+		auto &bind_data = finalize_data.input.bind_data->template Cast<ApproximateQuantileBindData>();
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		target = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state.h->quantile(bind_data.quantiles[0]));
 	}
 };
 
@@ -212,65 +209,32 @@ template <class CHILD_TYPE>
 struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 
 	template <class RESULT_TYPE, class STATE>
-	static void Finalize(Vector &result_list, AggregateInputData &aggr_input_data, STATE *state, RESULT_TYPE *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, RESULT_TYPE &target, AggregateFinalizeData &finalize_data) {
+		if (state.pos == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
 
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
+		D_ASSERT(finalize_data.input.bind_data);
+		auto &bind_data = finalize_data.input.bind_data->template Cast<ApproximateQuantileBindData>();
 
-		auto &result = ListVector::GetEntry(result_list);
-		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
+		auto &result = ListVector::GetEntry(finalize_data.result);
+		auto ridx = ListVector::GetListSize(finalize_data.result);
+		ListVector::Reserve(finalize_data.result, ridx + bind_data.quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
-		D_ASSERT(state->h);
-		state->h->compress();
+		D_ASSERT(state.h);
+		state.h->compress();
 
-		auto &entry = target[idx];
+		auto &entry = target;
 		entry.offset = ridx;
-		entry.length = bind_data->quantiles.size();
+		entry.length = bind_data.quantiles.size();
 		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data->quantiles[q];
-			rdata[ridx + q] = Cast::template Operation<SAVE_TYPE, CHILD_TYPE>(state->h->quantile(quantile));
-		}
-
-		ListVector::SetListSize(result_list, entry.offset + entry.length);
-	}
-
-	template <class STATE_TYPE, class RESULT_TYPE>
-	static void FinalizeList(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count, // NOLINT
-	                         idx_t offset) {
-		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
-
-		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data->quantiles.size());
-
-			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
-			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
-			auto &mask = ConstantVector::Validity(result);
-			Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[0], rdata, mask, 0);
-		} else {
-			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
-
-			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
-			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
-			auto &mask = FlatVector::Validity(result);
-			for (idx_t i = 0; i < count; i++) {
-				Finalize<RESULT_TYPE, STATE_TYPE>(result, aggr_input_data, sdata[i], rdata, mask, i + offset);
-			}
+			const auto &quantile = bind_data.quantiles[q];
+			rdata[ridx + q] = Cast::template Operation<SAVE_TYPE, CHILD_TYPE>(state.h->quantile(quantile));
 		}
 
-		result.Verify(count);
+		ListVector::SetListSize(finalize_data.result, entry.offset + entry.length);
 	}
 };
 
@@ -280,8 +244,8 @@ static AggregateFunction ApproxQuantileListAggregate(const LogicalType &input_ty
 	return AggregateFunction(
 	    {input_type}, result_type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
 	    AggregateFunction::UnaryScatterUpdate<STATE, INPUT_TYPE, OP>, AggregateFunction::StateCombine<STATE, OP>,
-	    OP::template FinalizeList<STATE, RESULT_TYPE>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>, nullptr,
-	    AggregateFunction::StateDestroy<STATE, OP>);
+	    AggregateFunction::StateFinalize<STATE, RESULT_TYPE, OP>, AggregateFunction::UnaryUpdate<STATE, INPUT_TYPE, OP>,
+	    nullptr, AggregateFunction::StateDestroy<STATE, OP>);
 }
 
 template <typename INPUT_TYPE, typename SAVE_TYPE>

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

@@ -150,126 +150,124 @@ struct ModeAssignmentString {
 template <typename KEY_TYPE, typename ASSIGN_OP>
 struct ModeFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
+	static void Initialize(STATE &state) {
+		state.Initialize();
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->frequency_map) {
-			state->frequency_map = new typename STATE::Counts();
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
+		if (!state.frequency_map) {
+			state.frequency_map = new typename STATE::Counts();
 		}
-		auto key = KEY_TYPE(input[idx]);
-		auto &i = (*state->frequency_map)[key];
+		auto key = KEY_TYPE(input);
+		auto &i = (*state.frequency_map)[key];
 		i.count++;
-		i.first_row = MinValue<idx_t>(i.first_row, state->count);
-		state->count++;
+		i.first_row = MinValue<idx_t>(i.first_row, state.count);
+		state.count++;
 	}
 
 	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.frequency_map) {
 			return;
 		}
-		if (!target->frequency_map) {
+		if (!target.frequency_map) {
 			// Copy - don't destroy! Otherwise windowing will break.
-			target->frequency_map = new typename STATE::Counts(*source.frequency_map);
+			target.frequency_map = new typename STATE::Counts(*source.frequency_map);
 			return;
 		}
 		for (auto &val : *source.frequency_map) {
-			auto &i = (*target->frequency_map)[val.first];
+			auto &i = (*target.frequency_map)[val.first];
 			i.count += val.second.count;
 			i.first_row = MinValue(i.first_row, val.second.first_row);
 		}
-		target->count += source.count;
+		target.count += source.count;
 	}
 
-	template <class INPUT_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, INPUT_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		if (!state->frequency_map) {
-			mask.SetInvalid(idx);
+	template <class T, class STATE>
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.frequency_map) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto highest_frequency = state->Scan();
-		if (highest_frequency != state->frequency_map->end()) {
-			target[idx] = ASSIGN_OP::template Assign<INPUT_TYPE, INPUT_TYPE>(result, highest_frequency->first);
+		auto highest_frequency = state.Scan();
+		if (highest_frequency != state.frequency_map->end()) {
+			target = ASSIGN_OP::template Assign<T, T>(finalize_data.result, highest_frequency->first);
 		} else {
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		if (!state->frequency_map) {
-			state->frequency_map = new typename STATE::Counts();
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &, idx_t count) {
+		if (!state.frequency_map) {
+			state.frequency_map = new typename STATE::Counts();
 		}
-		auto key = KEY_TYPE(input[0]);
-		auto &i = (*state->frequency_map)[key];
+		auto key = KEY_TYPE(input);
+		auto &i = (*state.frequency_map)[key];
 		i.count += count;
-		i.first_row = MinValue<idx_t>(i.first_row, state->count);
-		state->count += count;
+		i.first_row = MinValue<idx_t>(i.first_row, state.count);
+		state.count += count;
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &, 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);
 
 		ModeIncluded included(fmask, dmask, bias);
 
-		if (!state->frequency_map) {
-			state->frequency_map = new typename STATE::Counts;
+		if (!state.frequency_map) {
+			state.frequency_map = new typename STATE::Counts;
 		}
 		const double tau = .25;
-		if (state->nonzero <= tau * state->frequency_map->size()) {
-			state->Reset();
+		if (state.nonzero <= tau * state.frequency_map->size()) {
+			state.Reset();
 			// for f ∈ F do
 			for (auto f = frame.first; f < frame.second; ++f) {
 				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]), f);
+					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 		} else {
 			// for f ∈ P \ F do
 			for (auto p = prev.first; p < frame.first; ++p) {
 				if (included(p)) {
-					state->ModeRm(KEY_TYPE(data[p]), p);
+					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
 			for (auto p = frame.second; p < prev.second; ++p) {
 				if (included(p)) {
-					state->ModeRm(KEY_TYPE(data[p]), p);
+					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
 
 			// for f ∈ F \ P do
 			for (auto f = frame.first; f < prev.first; ++f) {
 				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]), f);
+					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 			for (auto f = prev.second; f < frame.second; ++f) {
 				if (included(f)) {
-					state->ModeAdd(KEY_TYPE(data[f]), f);
+					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 		}
 
-		if (!state->valid) {
+		if (!state.valid) {
 			// Rescan
-			auto highest_frequency = state->Scan();
-			if (highest_frequency != state->frequency_map->end()) {
-				*(state->mode) = highest_frequency->first;
-				state->count = highest_frequency->second.count;
-				state->valid = (state->count > 0);
+			auto highest_frequency = state.Scan();
+			if (highest_frequency != state.frequency_map->end()) {
+				*(state.mode) = highest_frequency->first;
+				state.count = highest_frequency->second.count;
+				state.valid = (state.count > 0);
 			}
 		}
 
-		if (state->valid) {
-			rdata[rid] = ASSIGN_OP::template Assign<INPUT_TYPE, RESULT_TYPE>(result, *state->mode);
+		if (state.valid) {
+			rdata[rid] = ASSIGN_OP::template Assign<INPUT_TYPE, RESULT_TYPE>(result, *state.mode);
 		} else {
 			rmask.Set(rid, false);
 		}
@@ -280,8 +278,8 @@ struct ModeFunction {
 	}
 
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->Destroy();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		state.Destroy();
 	}
 };