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

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -7,6 +7,8 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
 
 namespace duckdb {
 
@@ -106,6 +108,28 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &c
 	if (!lstate.local_index->MergeIndexes(*art)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+#ifdef DEBUG
+	// ensure that all row IDs of this chunk exist in the ART
+	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
+	for (idx_t i = 0; i < lstate.key_chunk.size(); i++) {
+		auto leaf_node =
+		    lstate.local_index->Cast<ART>().Lookup(*lstate.local_index->Cast<ART>().tree, lstate.keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(lstate.local_index->Cast<ART>(), leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(lstate.local_index->Cast<ART>(), leaf_segment, row_ids[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -119,6 +143,9 @@ void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gs
 	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+	// vacuum excess memory
+	gstate.global_index->Vacuum();
 }
 
 SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -127,6 +154,8 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 	// here, we just set the resulting global index as the newly created index of the table
 
 	auto &state = gstate_p.Cast<CreateIndexGlobalSinkState>();
+	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
+
 	auto &storage = table.GetStorage();
 	if (!storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
@@ -147,9 +176,6 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
-	// vacuum excess memory
-	state.global_index->Vacuum();
-
 	// add index to storage
 	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -45,7 +45,7 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, DataChunk &ch
 		gstate.capacity *= 2;
 	}
 
-	auto src_ptr = (string_t *)sdata.data;
+	auto src_ptr = UnifiedVectorFormat::GetData<string_t>(sdata);
 	auto result_ptr = FlatVector::GetData<string_t>(gstate.result);
 	// Input vector has NULL value, we just throw an exception
 	for (idx_t i = 0; i < chunk.size(); i++) {

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -51,7 +51,7 @@ PerfectAggregateHashTable::~PerfectAggregateHashTable() {
 template <class T>
 static void ComputeGroupLocationTemplated(UnifiedVectorFormat &group_data, Value &min, uintptr_t *address_data,
                                           idx_t current_shift, idx_t count) {
-	auto data = (T *)group_data.data;
+	auto data = UnifiedVectorFormat::GetData<T>(group_data);
 	auto min_val = min.GetValueUnsafe<T>();
 	if (!group_data.validity.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -186,7 +186,7 @@ static bool PlanIndexJoin(ClientContext &context, LogicalComparisonJoin &op, uni
 	}
 	// index joins are not supported if there are pushed down table filters
 	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	auto &tbl_scan = (PhysicalTableScan &)*right;
+	auto &tbl_scan = right->Cast<PhysicalTableScan>();
 	//	if (tbl_scan.table_filters && !tbl_scan.table_filters->filters.empty()) {
 	//		return false;
 	//	}

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -34,7 +34,7 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 }
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
-	const auto &create_info = (CreateTableInfo &)*op.info->base;
+	const auto &create_info = op.info->base->Cast<CreateTableInfo>();
 	auto &catalog = op.info->schema.catalog;
 	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table,
 	                                                          OnEntryNotFound::RETURN_NULL);

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -207,10 +207,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 		plan = CreatePlan(op.Cast<LogicalReset>());
 		break;
 	case LogicalOperatorType::LOGICAL_PIVOT:
-		plan = CreatePlan((LogicalPivot &)op);
+		plan = CreatePlan(op.Cast<LogicalPivot>());
 		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		plan = ((LogicalExtensionOperator &)op).CreatePlan(context, *this);
+		plan = op.Cast<LogicalExtensionOperator>().CreatePlan(context, *this);
 
 		if (!plan) {
 			throw InternalException("Missing PhysicalOperator for Extension Operator");

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -408,7 +408,7 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 			aggr.function.initialize(aggr_state.get());
 
 			AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
-			Vector state_vector(Value::POINTER((uintptr_t)aggr_state.get()));
+			Vector state_vector(Value::POINTER(CastPointerToValue(aggr_state.get())));
 			aggr.function.finalize(state_vector, aggr_input_data, chunk.data[null_groups.size() + i], 1, 0);
 			if (aggr.function.destructor) {
 				aggr.function.destructor(state_vector, aggr_input_data, 1);

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -186,7 +186,7 @@ void BaseReservoirSampling::InitializeReservoir(idx_t cur_size, idx_t sample_siz
 		//! we use a priority queue to extract the minimum key in O(1) time
 		for (idx_t i = 0; i < sample_size; i++) {
 			double k_i = random.NextRandom();
-			reservoir_weights.push(std::make_pair(-k_i, i));
+			reservoir_weights.emplace(-k_i, i);
 		}
 		SetNextEntry();
 	}
@@ -217,7 +217,7 @@ void BaseReservoirSampling::ReplaceElement() {
 	//! we generate a random number between (min_threshold, 1)
 	double r2 = random.NextRandom(min_threshold, 1);
 	//! now we insert the new weight into the reservoir
-	reservoir_weights.push(std::make_pair(-r2, min_entry));
+	reservoir_weights.emplace(-r2, min_entry);
 	//! we update the min entry with the new min entry in the reservoir
 	SetNextEntry();
 }

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -12,7 +12,8 @@ namespace duckdb {
 
 WindowAggregateState::WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p)
     : aggr(std::move(aggr)), result_type(result_type_p), state(aggr.function.state_size()),
-      statev(Value::POINTER((idx_t)state.data())), statep(Value::POINTER((idx_t)state.data())) {
+      statev(Value::POINTER(CastPointerToValue(state.data()))),
+      statep(Value::POINTER(CastPointerToValue(state.data()))) {
 	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 }
 
@@ -180,11 +181,12 @@ void WindowConstantAggregate::Compute(Vector &target, idx_t rid, idx_t start, id
 //===--------------------------------------------------------------------===//
 // WindowSegmentTree
 //===--------------------------------------------------------------------===//
-WindowSegmentTree::WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type_p, DataChunk *input,
+WindowSegmentTree::WindowSegmentTree(AggregateObject aggr_p, const LogicalType &result_type_p, DataChunk *input,
                                      const ValidityMask &filter_mask_p, WindowAggregationMode mode_p)
-    : aggr(std::move(aggr)), result_type(result_type_p), state(aggr.function.state_size()),
-      statep(Value::POINTER((idx_t)state.data())), frame(0, 0), statev(Value::POINTER((idx_t)state.data())),
-      internal_nodes(0), input_ref(input), filter_mask(filter_mask_p), mode(mode_p) {
+    : aggr(std::move(aggr_p)), result_type(result_type_p), state(aggr.function.state_size()),
+      statep(Value::POINTER(CastPointerToValue(state.data()))), frame(0, 0),
+      statev(Value::POINTER(CastPointerToValue(state.data()))), internal_nodes(0), input_ref(input),
+      filter_mask(filter_mask_p), mode(mode_p) {
 	statep.Flatten(input->size());
 	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 
@@ -212,7 +214,7 @@ WindowSegmentTree::~WindowSegmentTree() {
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
 	// call the destructor for all the intermediate states
 	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
-	Vector addresses(LogicalType::POINTER, (data_ptr_t)address_data);
+	Vector addresses(LogicalType::POINTER, data_ptr_cast(address_data));
 	idx_t count = 0;
 	for (idx_t i = 0; i < internal_nodes; i++) {
 		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state.size());

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -7,30 +7,30 @@ namespace duckdb {
 
 struct BaseCountFunction {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		*state = 0;
+	static void Initialize(STATE &state) {
+		state = 0;
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		*target += source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target += source;
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		target[idx] = *state;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		target = state;
 	}
 };
 
 struct CountStarFunction : public BaseCountFunction {
 	template <class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, idx_t idx) {
-		*state += 1;
+	static void Operation(STATE &state, AggregateInputData &, idx_t idx) {
+		state += 1;
 	}
 
 	template <class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, idx_t count) {
-		*state += count;
+	static void ConstantOperation(STATE &state, AggregateInputData &, idx_t count) {
+		state += count;
 	}
 
 	template <typename RESULT_TYPE>
@@ -55,27 +55,165 @@ struct CountStarFunction : public BaseCountFunction {
 };
 
 struct CountFunction : public BaseCountFunction {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		*state += 1;
+	using STATE = int64_t;
+
+	static void Operation(STATE &state) {
+		state += 1;
 	}
 
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		*state += count;
+	static void ConstantOperation(STATE &state, idx_t count) {
+		state += count;
 	}
 
 	static bool IgnoreNull() {
 		return true;
 	}
+
+	static inline void CountFlatLoop(STATE **__restrict states, ValidityMask &mask, idx_t count) {
+		if (!mask.AllValid()) {
+			idx_t base_idx = 0;
+			auto entry_count = ValidityMask::EntryCount(count);
+			for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
+				auto validity_entry = mask.GetValidityEntry(entry_idx);
+				idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
+				if (ValidityMask::AllValid(validity_entry)) {
+					// all valid: perform operation
+					for (; base_idx < next; base_idx++) {
+						CountFunction::Operation(*states[base_idx]);
+					}
+				} else if (ValidityMask::NoneValid(validity_entry)) {
+					// nothing valid: skip all
+					base_idx = next;
+					continue;
+				} else {
+					// partially valid: need to check individual elements for validity
+					idx_t start = base_idx;
+					for (; base_idx < next; base_idx++) {
+						if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
+							CountFunction::Operation(*states[base_idx]);
+						}
+					}
+				}
+			}
+		} else {
+			for (idx_t i = 0; i < count; i++) {
+				CountFunction::Operation(*states[i]);
+			}
+		}
+	}
+
+	static inline void CountScatterLoop(STATE **__restrict states, const SelectionVector &isel,
+	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
+		if (!mask.AllValid()) {
+			// potential NULL values
+			for (idx_t i = 0; i < count; i++) {
+				auto idx = isel.get_index(i);
+				auto sidx = ssel.get_index(i);
+				if (mask.RowIsValid(idx)) {
+					CountFunction::Operation(*states[sidx]);
+				}
+			}
+		} else {
+			// quick path: no NULL values
+			for (idx_t i = 0; i < count; i++) {
+				auto sidx = ssel.get_index(i);
+				CountFunction::Operation(*states[sidx]);
+			}
+		}
+	}
+
+	static void CountScatter(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
+	                         idx_t count) {
+		auto &input = inputs[0];
+		if (input.GetVectorType() == VectorType::FLAT_VECTOR && states.GetVectorType() == VectorType::FLAT_VECTOR) {
+			auto sdata = FlatVector::GetData<STATE *>(states);
+			CountFlatLoop(sdata, FlatVector::Validity(input), count);
+		} else {
+			UnifiedVectorFormat idata, sdata;
+			input.ToUnifiedFormat(count, idata);
+			states.ToUnifiedFormat(count, sdata);
+			CountScatterLoop(reinterpret_cast<STATE **>(sdata.data), *idata.sel, *sdata.sel, idata.validity, count);
+		}
+	}
+
+	static inline void CountFlatUpdateLoop(STATE &result, ValidityMask &mask, idx_t count) {
+		idx_t base_idx = 0;
+		auto entry_count = ValidityMask::EntryCount(count);
+		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
+			auto validity_entry = mask.GetValidityEntry(entry_idx);
+			idx_t next = MinValue<idx_t>(base_idx + ValidityMask::BITS_PER_VALUE, count);
+			if (ValidityMask::AllValid(validity_entry)) {
+				// all valid
+				result += next - base_idx;
+				base_idx = next;
+			} else if (ValidityMask::NoneValid(validity_entry)) {
+				// nothing valid: skip all
+				base_idx = next;
+				continue;
+			} else {
+				// partially valid: need to check individual elements for validity
+				idx_t start = base_idx;
+				for (; base_idx < next; base_idx++) {
+					if (ValidityMask::RowIsValid(validity_entry, base_idx - start)) {
+						result++;
+					}
+				}
+			}
+		}
+	}
+
+	static inline void CountUpdateLoop(STATE &result, ValidityMask &mask, idx_t count,
+	                                   const SelectionVector &sel_vector) {
+		if (mask.AllValid()) {
+			// no NULL values
+			result += count;
+			return;
+		}
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel_vector.get_index(i);
+			if (mask.RowIsValid(idx)) {
+				result++;
+			}
+		}
+	}
+
+	static void CountUpdate(Vector inputs[], AggregateInputData &, idx_t input_count, data_ptr_t state_p, idx_t count) {
+		auto &input = inputs[0];
+		auto &result = *reinterpret_cast<STATE *>(state_p);
+		switch (input.GetVectorType()) {
+		case VectorType::CONSTANT_VECTOR: {
+			if (!ConstantVector::IsNull(input)) {
+				// if the constant is not null increment the state
+				result += count;
+			}
+			break;
+		}
+		case VectorType::FLAT_VECTOR: {
+			CountFlatUpdateLoop(result, FlatVector::Validity(input), count);
+			break;
+		}
+		case VectorType::SEQUENCE_VECTOR: {
+			// sequence vectors cannot have NULL values
+			result += count;
+			break;
+		}
+		default: {
+			UnifiedVectorFormat idata;
+			input.ToUnifiedFormat(count, idata);
+			CountUpdateLoop(result, idata.validity, count, *idata.sel);
+			break;
+		}
+		}
+	}
 };
 
 AggregateFunction CountFun::GetFunction() {
-	auto fun = AggregateFunction::UnaryAggregate<int64_t, int64_t, int64_t, CountFunction>(
-	    LogicalType(LogicalTypeId::ANY), LogicalType::BIGINT);
+	AggregateFunction fun({LogicalType(LogicalTypeId::ANY)}, LogicalType::BIGINT, AggregateFunction::StateSize<int64_t>,
+	                      AggregateFunction::StateInitialize<int64_t, CountFunction>, CountFunction::CountScatter,
+	                      AggregateFunction::StateCombine<int64_t, CountFunction>,
+	                      AggregateFunction::StateFinalize<int64_t, int64_t, CountFunction>,
+	                      FunctionNullHandling::SPECIAL_HANDLING, CountFunction::CountUpdate);
 	fun.name = "count";
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -14,9 +14,9 @@ struct FirstState {
 
 struct FirstFunctionBase {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->is_set = false;
-		state->is_null = false;
+	static void Initialize(STATE &state) {
+		state.is_set = false;
+		state.is_null = false;
 	}
 
 	static bool IgnoreNull() {
@@ -27,40 +27,40 @@ struct FirstFunctionBase {
 template <bool LAST, bool SKIP_NULLS>
 struct FirstFunction : public FirstFunctionBase {
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (LAST || !state->is_set) {
-			if (!mask.RowIsValid(idx)) {
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (LAST || !state.is_set) {
+			if (!unary_input.RowIsValid()) {
 				if (!SKIP_NULLS) {
-					state->is_set = true;
+					state.is_set = true;
 				}
-				state->is_null = true;
+				state.is_null = true;
 			} else {
-				state->is_set = true;
-				state->is_null = false;
-				state->value = input[idx];
+				state.is_set = true;
+				state.is_null = false;
+				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) {
-		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) {
+		Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (!target->is_set) {
-			*target = source;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (!target.is_set) {
+			target = source;
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set || state->is_null) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set || state.is_null) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = state->value;
+			target = state.value;
 		}
 	}
 };
@@ -68,65 +68,64 @@ struct FirstFunction : public FirstFunctionBase {
 template <bool LAST, bool SKIP_NULLS>
 struct FirstFunctionString : public FirstFunctionBase {
 	template <class STATE>
-	static void SetValue(STATE *state, AggregateInputData &input_data, string_t value, bool is_null) {
-		if (LAST && state->is_set) {
-			Destroy(input_data, state);
+	static void SetValue(STATE &state, AggregateInputData &input_data, string_t value, bool is_null) {
+		if (LAST && state.is_set) {
+			Destroy(state, input_data);
 		}
 		if (is_null) {
 			if (!SKIP_NULLS) {
-				state->is_set = true;
-				state->is_null = true;
+				state.is_set = true;
+				state.is_null = true;
 			}
 		} else {
-			state->is_set = true;
-			state->is_null = false;
+			state.is_set = true;
+			state.is_null = false;
 			if (value.IsInlined()) {
-				state->value = value;
+				state.value = value;
 			} else {
 				// non-inlined string, need to allocate space for it
 				auto len = value.GetSize();
 				auto ptr = new char[len];
 				memcpy(ptr, value.GetData(), len);
 
-				state->value = string_t(ptr, len);
+				state.value = string_t(ptr, len);
 			}
 		}
 	}
 
 	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 (LAST || !state->is_set) {
-			SetValue(state, input_data, input[idx], !mask.RowIsValid(idx));
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &unary_input) {
+		if (LAST || !state.is_set) {
+			SetValue(state, unary_input.input, input, !unary_input.RowIsValid());
 		}
 	}
 
 	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) {
-		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) {
+		Operation<INPUT_TYPE, STATE, OP>(state, input, unary_input);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &input_data) {
-		if (source.is_set && (LAST || !target->is_set)) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &input_data) {
+		if (source.is_set && (LAST || !target.is_set)) {
 			SetValue(target, input_data, source.value, source.is_null);
 		}
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (!state->is_set || state->is_null) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (!state.is_set || state.is_null) {
+			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->is_null && !state->value.IsInlined()) {
-			delete[] state->value.GetData();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		if (state.is_set && !state.is_null && !state.value.IsInlined()) {
+			delete[] state.value.GetData();
 		}
 	}
 };
@@ -138,14 +137,14 @@ struct FirstStateVector {
 template <bool LAST, bool SKIP_NULLS>
 struct FirstVectorFunction {
 	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;
 		}
 	}
 	static bool IgnoreNull() {
@@ -153,14 +152,14 @@ struct FirstVectorFunction {
 	}
 
 	template <class STATE>
-	static void SetValue(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 SetValue(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);
 	}
 
 	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
@@ -171,39 +170,32 @@ struct FirstVectorFunction {
 		UnifiedVectorFormat sdata;
 		state_vector.ToUnifiedFormat(count, sdata);
 
-		auto states = (FirstStateVector **)sdata.data;
+		auto states = UnifiedVectorFormat::GetData<FirstStateVector *>(sdata);
 		for (idx_t i = 0; i < count; i++) {
 			const auto idx = idata.sel->get_index(i);
 			if (SKIP_NULLS && !idata.validity.RowIsValid(idx)) {
 				continue;
 			}
-			auto state = states[sdata.sel->get_index(i)];
-			if (LAST || !state->value) {
+			auto &state = *states[sdata.sel->get_index(i)];
+			if (LAST || !state.value) {
 				SetValue(state, input, i);
 			}
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		if (source.value && (LAST || !target->value)) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (source.value && (LAST || !target.value)) {
 			SetValue(target, *source.value, 0);
 		}
 	}
 
-	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 FlatVector::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
-			if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-				ConstantVector::SetNull(result, true);
-			} else {
-				FlatVector::SetNull(result, idx, true);
-			}
+	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);
 		}
 	}
 
@@ -289,7 +281,7 @@ static AggregateFunction GetFirstFunction(const LogicalType &type) {
 		return AggregateFunction({type}, type, AggregateFunction::StateSize<FirstStateVector>,
 		                         AggregateFunction::StateInitialize<FirstStateVector, OP>, OP::Update,
 		                         AggregateFunction::StateCombine<FirstStateVector, OP>,
-		                         AggregateFunction::StateFinalize<FirstStateVector, void, OP>, nullptr, OP::Bind,
+		                         AggregateFunction::StateVoidFinalize<FirstStateVector, OP>, nullptr, OP::Bind,
 		                         AggregateFunction::StateDestroy<FirstStateVector, OP>, nullptr, nullptr);
 	}
 	}