duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

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

@@ -16,67 +16,66 @@ struct KurtosisState {
 
 struct KurtosisOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->n = 0;
-		state->sum = state->sum_sqr = state->sum_cub = state->sum_four = 0.0;
+	static void Initialize(STATE &state) {
+		state.n = 0;
+		state.sum = state.sum_sqr = state.sum_cub = state.sum_four = 0.0;
 	}
 
 	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);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const 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);
-		state->sum_four += pow(data[idx], 4);
+	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);
+		state.sum_four += pow(input, 4);
 	}
 
 	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->sum_four += source.sum_four;
+		target.n += source.n;
+		target.sum += source.sum;
+		target.sum_sqr += source.sum_sqr;
+		target.sum_cub += source.sum_cub;
+		target.sum_four += source.sum_four;
 	}
 
 	template <class TARGET_TYPE, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, TARGET_TYPE *target, ValidityMask &mask,
-	                     idx_t idx) {
-		auto n = (double)state->n;
+	static void Finalize(STATE &state, TARGET_TYPE &target, AggregateFinalizeData &finalize_data) {
+		auto n = (double)state.n;
 		if (n <= 3) {
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 			return;
 		}
 		double temp = 1 / n;
 		//! This is necessary due to linux 32 bits
 		long double temp_aux = 1 / n;
-		if (state->sum_sqr - state->sum * state->sum * temp == 0 ||
-		    state->sum_sqr - state->sum * state->sum * temp_aux == 0) {
-			mask.SetInvalid(idx);
+		if (state.sum_sqr - state.sum * state.sum * temp == 0 ||
+		    state.sum_sqr - state.sum * state.sum * temp_aux == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
 		double m4 =
-		    temp * (state->sum_four - 4 * state->sum_cub * state->sum * temp +
-		            6 * state->sum_sqr * state->sum * state->sum * temp * temp - 3 * pow(state->sum, 4) * pow(temp, 3));
+		    temp * (state.sum_four - 4 * state.sum_cub * state.sum * temp +
+		            6 * state.sum_sqr * state.sum * state.sum * temp * temp - 3 * pow(state.sum, 4) * pow(temp, 3));
 
-		double m2 = temp * (state->sum_sqr - state->sum * state->sum * temp);
+		double m2 = temp * (state.sum_sqr - state.sum * state.sum * temp);
 		if (m2 <= 0 || ((n - 2) * (n - 3)) == 0) { // m2 shouldn't be below 0 but floating points are weird
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 			return;
 		}
-		target[idx] = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
-		if (!Value::DoubleIsFinite(target[idx])) {
+		target = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
+		if (!Value::DoubleIsFinite(target)) {
 			throw OutOfRangeException("Kurtosis is out of range!");
 		}
 	}

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, const INPUT_TYPE *input,
-	                              ValidityMask &mask, 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;
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input,
+	                              idx_t count) {
+		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, const 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);
 		}
 	}
 };
@@ -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 &, const 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, 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/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, 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);
 		}
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, const 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!");
 		}
 	}