duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

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

@@ -2,7 +2,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/hyperloglog.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 
@@ -16,52 +15,50 @@ struct ApproxDistinctCountState {
 			delete log;
 		}
 	}
-	void Resize(idx_t count) {
-		indices.resize(count);
-		counts.resize(count);
-	}
 
 	HyperLogLog *log;
-	vector<uint64_t> indices;
-	vector<uint8_t> counts;
 };
 
 struct ApproxCountDistinctFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE;
+	static void Initialize(STATE &state) {
+		state.log = nullptr;
 	}
 
 	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.log) {
 			return;
 		}
-		if (!target->log) {
-			target->log = new HyperLogLog();
+		if (!target.log) {
+			target.log = new HyperLogLog();
 		}
-		D_ASSERT(target->log);
+		D_ASSERT(target.log);
 		D_ASSERT(source.log);
-		auto new_log = target->log->MergePointer(*source.log);
-		delete target->log;
-		target->log = new_log;
+		auto new_log = target.log->MergePointer(*source.log);
+		delete target.log;
+		target.log = new_log;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->log) {
-			target[idx] = state->log->Count();
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.log) {
+			target = state.log->Count();
 		} else {
-			target[idx] = 0;
+			target = 0;
 		}
 	}
 
 	static bool IgnoreNull() {
 		return true;
 	}
+
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->~STATE();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.log) {
+			delete state.log;
+			state.log = nullptr;
+		}
 	}
 };
 
@@ -69,7 +66,7 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
                                                     data_ptr_t state, idx_t count) {
 	D_ASSERT(input_count == 1);
 
-	auto agg_state = (ApproxDistinctCountState *)state;
+	auto agg_state = reinterpret_cast<ApproxDistinctCountState *>(state);
 	if (!agg_state->log) {
 		agg_state->log = new HyperLogLog();
 	}
@@ -77,10 +74,11 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
 	UnifiedVectorFormat vdata;
 	inputs[0].ToUnifiedFormat(count, vdata);
 
-	agg_state->Resize(count);
-	auto indices = agg_state->indices.data();
-	auto counts = agg_state->counts.data();
-
+	if (count > STANDARD_VECTOR_SIZE) {
+		throw InternalException("ApproxCountDistinct - count must be at most vector size");
+	}
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
 	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
 	agg_state->log->AddToLog(vdata, count, indices, counts);
 }
@@ -91,27 +89,25 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = (ApproxDistinctCountState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetDataNoConst<ApproxDistinctCountState *>(sdata);
 
-	uint64_t *indices = nullptr;
-	uint8_t *counts = nullptr;
 	for (idx_t i = 0; i < count; i++) {
 		auto agg_state = states[sdata.sel->get_index(i)];
 		if (!agg_state->log) {
 			agg_state->log = new HyperLogLog();
 		}
-		if (i == 0) {
-			agg_state->Resize(count);
-			indices = agg_state->indices.data();
-			counts = agg_state->counts.data();
-		}
 	}
 
 	UnifiedVectorFormat vdata;
 	inputs[0].ToUnifiedFormat(count, vdata);
 
+	if (count > STANDARD_VECTOR_SIZE) {
+		throw InternalException("ApproxCountDistinct - count must be at most vector size");
+	}
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
 	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
-	HyperLogLog::AddToLogs(vdata, count, indices, counts, (HyperLogLog ***)states, sdata.sel);
+	HyperLogLog::AddToLogs(vdata, count, indices, counts, reinterpret_cast<HyperLogLog ***>(states), sdata.sel);
 }
 
 AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) {

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

@@ -25,8 +25,8 @@ struct ArgMinMaxStateBase {
 	}
 
 	template <typename T>
-	static inline void ReadValue(Vector &result, T &arg, T *target, idx_t idx) {
-		target[idx] = arg;
+	static inline void ReadValue(Vector &result, T &arg, T &target) {
+		target = arg;
 	}
 
 	bool is_initialized;
@@ -69,8 +69,8 @@ void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, bool
 }
 
 template <>
-void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t *target, idx_t idx) {
-	target[idx] = StringVector::AddStringOrBlob(result, arg);
+void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t &target) {
+	target = StringVector::AddStringOrBlob(result, arg);
 }
 
 template <class A, class B>
@@ -97,54 +97,54 @@ struct ArgMinMaxState : public ArgMinMaxStateBase {
 
 template <class COMPARATOR>
 struct ArgMinMaxBase {
+
 	template <class STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->~STATE();
+	static void Initialize(STATE &state) {
+		new (&state) STATE;
 	}
 
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE;
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		state.~STATE();
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		if (!state->is_initialized) {
-			STATE::template AssignValue<A_TYPE>(state->arg, x_data[xidx], false);
-			STATE::template AssignValue<B_TYPE>(state->value, y_data[yidx], false);
-			state->is_initialized = true;
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &) {
+		if (!state.is_initialized) {
+			STATE::template AssignValue<A_TYPE>(state.arg, x, false);
+			STATE::template AssignValue<B_TYPE>(state.value, y, false);
+			state.is_initialized = true;
 		} else {
-			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x_data[xidx], y_data[yidx]);
+			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x, y);
 		}
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Execute(STATE *state, A_TYPE x_data, B_TYPE y_data) {
-		if (COMPARATOR::Operation(y_data, state->value)) {
-			STATE::template AssignValue<A_TYPE>(state->arg, x_data, true);
-			STATE::template AssignValue<B_TYPE>(state->value, y_data, true);
+	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data) {
+		if (COMPARATOR::Operation(y_data, state.value)) {
+			STATE::template AssignValue<A_TYPE>(state.arg, x_data, true);
+			STATE::template AssignValue<B_TYPE>(state.value, y_data, true);
 		}
 	}
 
 	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_initialized) {
 			return;
 		}
-		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			STATE::template AssignValue(target->arg, source.arg, target->is_initialized);
-			STATE::template AssignValue(target->value, source.value, target->is_initialized);
-			target->is_initialized = true;
+		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
+			STATE::template AssignValue(target.arg, source.arg, target.is_initialized);
+			STATE::template AssignValue(target.value, source.value, target.is_initialized);
+			target.is_initialized = true;
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_initialized) {
+			finalize_data.ReturnNull();
 		} else {
-			STATE::template ReadValue(result, state->arg, target, idx);
+			STATE::template ReadValue(finalize_data.result, state.arg, target);
 		}
 	}
 
@@ -156,14 +156,14 @@ struct ArgMinMaxBase {
 template <typename COMPARATOR>
 struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 	template <class STATE>
-	static void AssignVector(STATE *state, Vector &arg, const idx_t idx) {
-		if (!state->is_initialized) {
-			state->arg = new Vector(arg.GetType());
-			state->arg->SetVectorType(VectorType::CONSTANT_VECTOR);
+	static void AssignVector(STATE &state, Vector &arg, const idx_t idx) {
+		if (!state.is_initialized) {
+			state.arg = new Vector(arg.GetType());
+			state.arg->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
 		sel_t selv = idx;
 		SelectionVector sel(&selv);
-		VectorOperations::Copy(arg, *state->arg, sel, 1, 0, 0);
+		VectorOperations::Copy(arg, *state.arg, sel, 1, 0, 0);
 	}
 
 	template <class STATE>
@@ -176,7 +176,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 		auto &by = inputs[1];
 		UnifiedVectorFormat bdata;
 		by.ToUnifiedFormat(count, bdata);
-		const auto bys = (BY_TYPE *)bdata.data;
+		const auto bys = UnifiedVectorFormat::GetData<BY_TYPE>(bdata);
 
 		UnifiedVectorFormat sdata;
 		state_vector.ToUnifiedFormat(count, sdata);
@@ -190,49 +190,37 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 			const auto bval = bys[bidx];
 
 			const auto sidx = sdata.sel->get_index(i);
-			auto state = states[sidx];
-			if (!state->is_initialized) {
-				STATE::template AssignValue<BY_TYPE>(state->value, bval, false);
+			auto &state = *states[sidx];
+			if (!state.is_initialized) {
+				STATE::template AssignValue<BY_TYPE>(state.value, bval, false);
 				AssignVector(state, arg, i);
-				state->is_initialized = true;
+				state.is_initialized = true;
 
-			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state->value)) {
-				STATE::template AssignValue<BY_TYPE>(state->value, bval, true);
+			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state.value)) {
+				STATE::template AssignValue<BY_TYPE>(state.value, bval, true);
 				AssignVector(state, arg, i);
 			}
 		}
 	}
 
 	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_initialized) {
 			return;
 		}
-		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			STATE::template AssignValue(target->value, source.value, target->is_initialized);
+		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
+			STATE::template AssignValue(target.value, source.value, target.is_initialized);
 			AssignVector(target, *source.arg, 0);
-			target->is_initialized = true;
+			target.is_initialized = true;
 		}
 	}
 
-	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_initialized) {
-			// 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 arg_min/max");
-			}
+	template <class STATE>
+	static void Finalize(STATE &state, AggregateFinalizeData &finalize_data) {
+		if (!state.is_initialized) {
+			finalize_data.ReturnNull();
 		} else {
-			VectorOperations::Copy(*state->arg, result, 1, 0, idx);
+			VectorOperations::Copy(*state.arg, finalize_data.result, 1, 0, finalize_data.result_idx);
 		}
 	}
 
@@ -247,11 +235,10 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 template <class OP, class ARG_TYPE, class BY_TYPE>
 AggregateFunction GetVectorArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
 	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
-	return AggregateFunction({type, by_type}, type, AggregateFunction::StateSize<STATE>,
-	                         AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE>,
-	                         AggregateFunction::StateCombine<STATE, OP>,
-	                         AggregateFunction::StateFinalize<STATE, void, OP>, nullptr, OP::Bind,
-	                         AggregateFunction::StateDestroy<STATE, OP>);
+	return AggregateFunction(
+	    {type, by_type}, type, AggregateFunction::StateSize<STATE>, AggregateFunction::StateInitialize<STATE, OP>,
+	    OP::template Update<STATE>, AggregateFunction::StateCombine<STATE, OP>,
+	    AggregateFunction::StateVoidFinalize<STATE, OP>, nullptr, OP::Bind, AggregateFunction::StateDestroy<STATE, OP>);
 }
 
 template <class OP, class ARG_TYPE>

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 &, 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, 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, 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, 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);
 		}
 	}
 };