duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -2,12 +2,14 @@
 
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/sort/partition_state.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/merge_sort_tree.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/execution/window_executor.hpp"
 
 #include <numeric>
+#include <thread>
 #include <utility>
 
 namespace duckdb {
@@ -18,50 +20,201 @@ namespace duckdb {
 WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) {
 }
 
-WindowAggregator::WindowAggregator(AggregateObject aggr_p, const LogicalType &result_type_p,
-                                   const WindowExcludeMode exclude_mode_p, idx_t partition_count_p)
-    : aggr(std::move(aggr_p)), result_type(result_type_p), partition_count(partition_count_p),
-      state_size(aggr.function.state_size()), filter_pos(0), exclude_mode(exclude_mode_p) {
+class WindowAggregatorGlobalState : public WindowAggregatorState {
+public:
+	WindowAggregatorGlobalState(const WindowAggregator &aggregator_p, idx_t group_count)
+	    : aggregator(aggregator_p), winputs(inputs), locals(0), finalized(0) {
+
+		if (!aggregator.arg_types.empty()) {
+			winputs.Initialize(Allocator::DefaultAllocator(), aggregator.arg_types, group_count);
+		}
+		if (aggregator.aggr.filter) {
+			// 	Start with all invalid and set the ones that pass
+			filter_mask.Initialize(group_count, false);
+		}
+	}
+
+	//! The aggregator data
+	const WindowAggregator &aggregator;
+
+	//! Partition data chunk
+	DataChunk inputs;
+	WindowDataChunk winputs;
+
+	//! The filtered rows in inputs.
+	ValidityArray filter_mask;
+
+	//! Lock for single threading
+	mutable mutex lock;
+
+	//! Count of local tasks
+	mutable std::atomic<idx_t> locals;
+
+	//! Number of finalised states
+	std::atomic<idx_t> finalized;
+};
+
+WindowAggregator::WindowAggregator(AggregateObject aggr_p, const vector<LogicalType> &arg_types_p,
+                                   const LogicalType &result_type_p, const WindowExcludeMode exclude_mode_p)
+    : aggr(std::move(aggr_p)), arg_types(arg_types_p), result_type(result_type_p),
+      state_size(aggr.function.state_size(aggr.function)), exclude_mode(exclude_mode_p) {
 }
 
 WindowAggregator::~WindowAggregator() {
 }
 
-void WindowAggregator::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
-	if (!inputs.ColumnCount() && payload_chunk.ColumnCount()) {
-		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
-	}
-	if (inputs.ColumnCount()) {
-		inputs.Append(payload_chunk, true);
+unique_ptr<WindowAggregatorState> WindowAggregator::GetGlobalState(idx_t group_count, const ValidityMask &) const {
+	return make_uniq<WindowAggregatorGlobalState>(*this, group_count);
+}
+
+void WindowAggregator::Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &arg_chunk,
+                            idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
+	auto &gasink = gsink.Cast<WindowAggregatorGlobalState>();
+	auto &winputs = gasink.winputs;
+	auto &filter_mask = gasink.filter_mask;
+	if (winputs.chunk.ColumnCount()) {
+		winputs.Copy(arg_chunk, input_idx);
 	}
 	if (filter_sel) {
-		//	Lazy instantiation
-		if (!filter_mask.IsMaskSet()) {
-			// 	Start with all invalid and set the ones that pass
-			filter_bits.resize(ValidityMask::ValidityMaskSize(partition_count), 0);
-			filter_mask.Initialize(filter_bits.data());
-		}
 		for (idx_t f = 0; f < filtered; ++f) {
-			filter_mask.SetValid(filter_pos + filter_sel->get_index(f));
+			filter_mask.SetValid(input_idx + filter_sel->get_index(f));
 		}
-		filter_pos += payload_chunk.size();
 	}
 }
 
-void WindowAggregator::Finalize(const FrameStats &stats) {
+void WindowAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats) {
 }
 
 //===--------------------------------------------------------------------===//
-// WindowConstantAggregate
+// WindowConstantAggregator
 //===--------------------------------------------------------------------===//
-WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type,
-                                                   const ValidityMask &partition_mask,
-                                                   const WindowExcludeMode exclude_mode_p, const idx_t count)
-    : WindowAggregator(std::move(aggr), result_type, exclude_mode_p, count), partition(0), row(0), state(state_size),
-      statep(Value::POINTER(CastPointerToValue(state.data()))),
-      statef(Value::POINTER(CastPointerToValue(state.data()))) {
+struct WindowAggregateStates {
+	explicit WindowAggregateStates(const AggregateObject &aggr);
+	~WindowAggregateStates() {
+		Destroy();
+	}
 
-	statef.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
+	//! The number of states
+	idx_t GetCount() const {
+		return states.size() / state_size;
+	}
+	data_ptr_t *GetData() {
+		return FlatVector::GetData<data_ptr_t>(*statef);
+	}
+	data_ptr_t GetStatePtr(idx_t idx) {
+		return states.data() + idx * state_size;
+	}
+	const_data_ptr_t GetStatePtr(idx_t idx) const {
+		return states.data() + idx * state_size;
+	}
+	//! Initialise all the states
+	void Initialize(idx_t count);
+	//! Combine the states into the target
+	void Combine(WindowAggregateStates &target,
+	             AggregateCombineType combine_type = AggregateCombineType::PRESERVE_INPUT);
+	//! Finalize the states into an output vector
+	void Finalize(Vector &result);
+	//! Destroy the states
+	void Destroy();
+
+	//! A description of the aggregator
+	const AggregateObject aggr;
+	//! The size of each state
+	const idx_t state_size;
+	//! The allocator to use
+	ArenaAllocator allocator;
+	//! Data pointer that contains the state data
+	vector<data_t> states;
+	//! Reused result state container for the window functions
+	unique_ptr<Vector> statef;
+};
+
+WindowAggregateStates::WindowAggregateStates(const AggregateObject &aggr)
+    : aggr(aggr), state_size(aggr.function.state_size(aggr.function)), allocator(Allocator::DefaultAllocator()) {
+}
+
+void WindowAggregateStates::Initialize(idx_t count) {
+	states.resize(count * state_size);
+	auto state_ptr = states.data();
+
+	statef = make_uniq<Vector>(LogicalType::POINTER, count);
+	auto state_f_data = FlatVector::GetData<data_ptr_t>(*statef);
+
+	for (idx_t i = 0; i < count; ++i, state_ptr += state_size) {
+		state_f_data[i] = state_ptr;
+		aggr.function.initialize(aggr.function, state_ptr);
+	}
+
+	// Prevent conversion of results to constants
+	statef->SetVectorType(VectorType::FLAT_VECTOR);
+}
+
+void WindowAggregateStates::Combine(WindowAggregateStates &target, AggregateCombineType combine_type) {
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator, AggregateCombineType::ALLOW_DESTRUCTIVE);
+	aggr.function.combine(*statef, *target.statef, aggr_input_data, GetCount());
+}
+
+void WindowAggregateStates::Finalize(Vector &result) {
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	aggr.function.finalize(*statef, aggr_input_data, result, GetCount(), 0);
+}
+
+void WindowAggregateStates::Destroy() {
+	if (states.empty()) {
+		return;
+	}
+
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	if (aggr.function.destructor) {
+		aggr.function.destructor(*statef, aggr_input_data, GetCount());
+	}
+
+	states.clear();
+}
+
+class WindowConstantAggregatorGlobalState : public WindowAggregatorGlobalState {
+public:
+	WindowConstantAggregatorGlobalState(const WindowConstantAggregator &aggregator, idx_t count,
+	                                    const ValidityMask &partition_mask);
+
+	void Finalize(const FrameStats &stats);
+
+	//! Partition starts
+	vector<idx_t> partition_offsets;
+	//! Reused result state container for the window functions
+	WindowAggregateStates statef;
+	//! Aggregate results
+	unique_ptr<Vector> results;
+};
+
+class WindowConstantAggregatorLocalState : public WindowAggregatorState {
+public:
+	explicit WindowConstantAggregatorLocalState(const WindowConstantAggregatorGlobalState &gstate);
+	~WindowConstantAggregatorLocalState() override {
+	}
+
+	void Sink(DataChunk &payload_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
+	void Combine(WindowConstantAggregatorGlobalState &gstate);
+
+public:
+	//! The global state we are sharing
+	const WindowConstantAggregatorGlobalState &gstate;
+	//! Reusable chunk for sinking
+	DataChunk inputs;
+	//! A vector of pointers to "state", used for intermediate window segment aggregation
+	Vector statep;
+	//! Reused result state container for the window functions
+	WindowAggregateStates statef;
+	//! The current result partition being read
+	idx_t partition;
+	//! Shared SV for evaluation
+	SelectionVector matches;
+};
+
+WindowConstantAggregatorGlobalState::WindowConstantAggregatorGlobalState(const WindowConstantAggregator &aggregator,
+                                                                         idx_t group_count,
+                                                                         const ValidityMask &partition_mask)
+    : WindowAggregatorGlobalState(aggregator, STANDARD_VECTOR_SIZE), statef(aggregator.aggr) {
 
 	// Locate the partition boundaries
 	if (partition_mask.AllValid()) {
@@ -69,7 +222,7 @@ WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const L
 	} else {
 		idx_t entry_idx;
 		idx_t shift;
-		for (idx_t start = 0; start < count;) {
+		for (idx_t start = 0; start < group_count;) {
 			partition_mask.GetEntryIndex(start, entry_idx, shift);
 
 			//	If start is aligned with the start of a block,
@@ -81,7 +234,7 @@ WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const L
 			}
 
 			// Loop over the block
-			for (; shift < ValidityMask::BITS_PER_VALUE && start < count; ++shift, ++start) {
+			for (; shift < ValidityMask::BITS_PER_VALUE && start < group_count; ++shift, ++start) {
 				if (partition_mask.RowIsValid(block, shift)) {
 					partition_offsets.emplace_back(start);
 				}
@@ -90,45 +243,70 @@ WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const L
 	}
 
 	//	Initialise the vector for caching the results
-	results = make_uniq<Vector>(result_type, partition_offsets.size());
-	partition_offsets.emplace_back(count);
+	results = make_uniq<Vector>(aggregator.result_type, partition_offsets.size());
 
-	//	Create an aggregate state for intermediate aggregates
-	gstate = make_uniq<WindowAggregatorState>();
+	//	Initialise the final states
+	statef.Initialize(partition_offsets.size());
 
-	//	Start the first aggregate
-	AggregateInit();
+	// Add final guard
+	partition_offsets.emplace_back(group_count);
 }
 
-void WindowConstantAggregator::AggregateInit() {
-	aggr.function.initialize(state.data());
+WindowConstantAggregatorLocalState::WindowConstantAggregatorLocalState(
+    const WindowConstantAggregatorGlobalState &gstate)
+    : gstate(gstate), statep(Value::POINTER(0)), statef(gstate.statef.aggr), partition(0) {
+	matches.Initialize();
+
+	//	Start the aggregates
+	auto &partition_offsets = gstate.partition_offsets;
+	auto &aggregator = gstate.aggregator;
+	statef.Initialize(partition_offsets.size() - 1);
+
+	// Set up shared buffer
+	inputs.Initialize(Allocator::DefaultAllocator(), aggregator.arg_types);
+
+	gstate.locals++;
 }
 
-void WindowConstantAggregator::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
-	aggr.function.finalize(statef, aggr_input_data, result, 1, rid);
+WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types,
+                                                   const LogicalType &result_type,
+                                                   const WindowExcludeMode exclude_mode_p)
+    : WindowAggregator(std::move(aggr), arg_types, result_type, exclude_mode_p) {
+}
 
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statef, aggr_input_data, 1);
-	}
+unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetGlobalState(idx_t group_count,
+                                                                           const ValidityMask &partition_mask) const {
+	return make_uniq<WindowConstantAggregatorGlobalState>(*this, group_count, partition_mask);
 }
 
-void WindowConstantAggregator::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
+void WindowConstantAggregator::Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &arg_chunk,
+                                    idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
+	auto &lastate = lstate.Cast<WindowConstantAggregatorLocalState>();
+
+	lastate.Sink(arg_chunk, input_idx, filter_sel, filtered);
+}
+
+void WindowConstantAggregatorLocalState::Sink(DataChunk &payload_chunk, idx_t row,
+                                              optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
+	auto &partition_offsets = gstate.partition_offsets;
+	auto &aggregator = gstate.aggregator;
+	const auto &aggr = aggregator.aggr;
 	const auto chunk_begin = row;
 	const auto chunk_end = chunk_begin + payload_chunk.size();
+	idx_t partition =
+	    idx_t(std::upper_bound(partition_offsets.begin(), partition_offsets.end(), row) - partition_offsets.begin()) -
+	    1;
 
-	if (!inputs.ColumnCount() && payload_chunk.ColumnCount()) {
-		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
-	}
+	auto state_f_data = statef.GetData();
+	auto state_p_data = FlatVector::GetData<data_ptr_t>(statep);
 
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 	idx_t begin = 0;
 	idx_t filter_idx = 0;
 	auto partition_end = partition_offsets[partition + 1];
 	while (row < chunk_end) {
 		if (row == partition_end) {
-			AggegateFinal(*results, partition++);
-			AggregateInit();
+			++partition;
 			partition_end = partition_offsets[partition + 1];
 		}
 		partition_end = MinValue(partition_end, chunk_end);
@@ -174,9 +352,11 @@ void WindowConstantAggregator::Sink(DataChunk &payload_chunk, SelectionVector *f
 
 		//	Aggregate the filtered rows into a single state
 		const auto count = inputs.size();
+		auto state = state_f_data[partition];
 		if (aggr.function.simple_update) {
-			aggr.function.simple_update(inputs.data.data(), aggr_input_data, inputs.ColumnCount(), state.data(), count);
+			aggr.function.simple_update(inputs.data.data(), aggr_input_data, inputs.ColumnCount(), state, count);
 		} else {
+			state_p_data[0] = state_f_data[partition];
 			aggr.function.update(inputs.data.data(), aggr_input_data, inputs.ColumnCount(), statep, count);
 		}
 
@@ -186,34 +366,36 @@ void WindowConstantAggregator::Sink(DataChunk &payload_chunk, SelectionVector *f
 	}
 }
 
-void WindowConstantAggregator::Finalize(const FrameStats &stats) {
-	AggegateFinal(*results, partition++);
-}
+void WindowConstantAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate,
+                                        const FrameStats &stats) {
+	auto &gastate = gstate.Cast<WindowConstantAggregatorGlobalState>();
+	auto &lastate = lstate.Cast<WindowConstantAggregatorLocalState>();
 
-class WindowConstantAggregatorState : public WindowAggregatorState {
-public:
-	WindowConstantAggregatorState() : partition(0) {
-		matches.Initialize();
-	}
-	~WindowConstantAggregatorState() override {
-	}
+	//	Single-threaded combine
+	lock_guard<mutex> finalize_guard(gastate.lock);
+	lastate.statef.Combine(gastate.statef);
+	lastate.statef.Destroy();
 
-public:
-	//! The current result partition being read
-	idx_t partition;
-	//! Shared SV for evaluation
-	SelectionVector matches;
-};
+	//	Last one out turns off the lights!
+	if (++gastate.finalized == gastate.locals) {
+		gastate.statef.Finalize(*gastate.results);
+		gastate.statef.Destroy();
+	}
+}
 
-unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetLocalState() const {
-	return make_uniq<WindowConstantAggregatorState>();
+unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
+	return make_uniq<WindowConstantAggregatorLocalState>(gstate.Cast<WindowConstantAggregatorGlobalState>());
 }
 
-void WindowConstantAggregator::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &target,
-                                        idx_t count, idx_t row_idx) const {
+void WindowConstantAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                        const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
+	auto &gasink = gsink.Cast<WindowConstantAggregatorGlobalState>();
+	const auto &partition_offsets = gasink.partition_offsets;
+	const auto &results = *gasink.results;
+
 	auto begins = FlatVector::GetData<const idx_t>(bounds.data[WINDOW_BEGIN]);
 	//	Chunk up the constants and copy them one at a time
-	auto &lcstate = lstate.Cast<WindowConstantAggregatorState>();
+	auto &lcstate = lstate.Cast<WindowConstantAggregatorLocalState>();
 	idx_t matched = 0;
 	idx_t target_offset = 0;
 	for (idx_t i = 0; i < count; ++i) {
@@ -222,7 +404,7 @@ void WindowConstantAggregator::Evaluate(WindowAggregatorState &lstate, const Dat
 		while (partition_offsets[lcstate.partition + 1] <= begin) {
 			//	Flush the previous partition's data
 			if (matched) {
-				VectorOperations::Copy(*results, target, lcstate.matches, matched, 0, target_offset);
+				VectorOperations::Copy(results, result, lcstate.matches, matched, 0, target_offset);
 				target_offset += matched;
 				matched = 0;
 			}
@@ -234,16 +416,22 @@ void WindowConstantAggregator::Evaluate(WindowAggregatorState &lstate, const Dat
 
 	//	Flush the last partition
 	if (matched) {
-		VectorOperations::Copy(*results, target, lcstate.matches, matched, 0, target_offset);
+		// Optimize constant result
+		if (target_offset == 0 && matched == count) {
+			VectorOperations::Copy(results, result, lcstate.matches, 1, 0, target_offset);
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		} else {
+			VectorOperations::Copy(results, result, lcstate.matches, matched, 0, target_offset);
+		}
 	}
 }
 
 //===--------------------------------------------------------------------===//
 // WindowCustomAggregator
 //===--------------------------------------------------------------------===//
-WindowCustomAggregator::WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type,
-                                               const WindowExcludeMode exclude_mode_p, idx_t count)
-    : WindowAggregator(std::move(aggr), result_type, exclude_mode_p, count) {
+WindowCustomAggregator::WindowCustomAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types,
+                                               const LogicalType &result_type, const WindowExcludeMode exclude_mode)
+    : WindowAggregator(std::move(aggr), arg_types, result_type, exclude_mode) {
 }
 
 WindowCustomAggregator::~WindowCustomAggregator() {
@@ -282,12 +470,28 @@ static void InitSubFrames(SubFrames &frames, const WindowExcludeMode exclude_mod
 	frames.resize(nframes, {0, 0});
 }
 
+class WindowCustomAggregatorGlobalState : public WindowAggregatorGlobalState {
+public:
+	explicit WindowCustomAggregatorGlobalState(const WindowCustomAggregator &aggregator, idx_t group_count)
+	    : WindowAggregatorGlobalState(aggregator, group_count) {
+
+		gcstate = make_uniq<WindowCustomAggregatorState>(aggregator.aggr, aggregator.exclude_mode);
+	}
+
+	//! Traditional packed filter mask for API
+	ValidityMask filter_packed;
+	//! Data pointer that contains a single local state, used for global custom window execution state
+	unique_ptr<WindowCustomAggregatorState> gcstate;
+	//! Partition description for custom window APIs
+	unique_ptr<WindowPartitionInput> partition_input;
+};
+
 WindowCustomAggregatorState::WindowCustomAggregatorState(const AggregateObject &aggr,
                                                          const WindowExcludeMode exclude_mode)
-    : aggr(aggr), state(aggr.function.state_size()), statef(Value::POINTER(CastPointerToValue(state.data()))),
-      frames(3, {0, 0}) {
+    : aggr(aggr), state(aggr.function.state_size(aggr.function)),
+      statef(Value::POINTER(CastPointerToValue(state.data()))), frames(3, {0, 0}) {
 	// if we have a frame-by-frame method, share the single state
-	aggr.function.initialize(state.data());
+	aggr.function.initialize(aggr.function, state.data());
 
 	InitSubFrames(frames, exclude_mode);
 }
@@ -299,21 +503,41 @@ WindowCustomAggregatorState::~WindowCustomAggregatorState() {
 	}
 }
 
-void WindowCustomAggregator::Finalize(const FrameStats &stats) {
-	WindowAggregator::Finalize(stats);
-	partition_input =
-	    make_uniq<WindowPartitionInput>(inputs.data.data(), inputs.ColumnCount(), inputs.size(), filter_mask, stats);
+unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetGlobalState(idx_t group_count,
+                                                                         const ValidityMask &) const {
+	return make_uniq<WindowCustomAggregatorGlobalState>(*this, group_count);
+}
+
+void WindowCustomAggregator::Finalize(WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                      const FrameStats &stats) {
+	//	Single threaded Finalize for now
+	auto &gcsink = gsink.Cast<WindowCustomAggregatorGlobalState>();
+	lock_guard<mutex> gestate_guard(gcsink.lock);
+	if (gcsink.finalized) {
+		return;
+	}
+
+	WindowAggregator::Finalize(gsink, lstate, stats);
+
+	auto &inputs = gcsink.inputs;
+	auto &filter_mask = gcsink.filter_mask;
+	auto &filter_packed = gcsink.filter_packed;
+	filter_mask.Pack(filter_packed, filter_mask.target_count);
+
+	gcsink.partition_input =
+	    make_uniq<WindowPartitionInput>(inputs.data.data(), inputs.ColumnCount(), inputs.size(), filter_packed, stats);
 
 	if (aggr.function.window_init) {
-		gstate = GetLocalState();
-		auto &gcstate = gstate->Cast<WindowCustomAggregatorState>();
+		auto &gcstate = *gcsink.gcstate;
 
 		AggregateInputData aggr_input_data(aggr.GetFunctionData(), gcstate.allocator);
-		aggr.function.window_init(aggr_input_data, *partition_input, gcstate.state.data());
+		aggr.function.window_init(aggr_input_data, *gcsink.partition_input, gcstate.state.data());
 	}
+
+	++gcsink.finalized;
 }
 
-unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetLocalState() const {
+unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
 	return make_uniq<WindowCustomAggregatorState>(aggr, exclude_mode);
 }
 
@@ -374,29 +598,30 @@ static void EvaluateSubFrames(const DataChunk &bounds, const WindowExcludeMode e
 	}
 }
 
-void WindowCustomAggregator::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result,
-                                      idx_t count, idx_t row_idx) const {
+void WindowCustomAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                      const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
 	auto &lcstate = lstate.Cast<WindowCustomAggregatorState>();
 	auto &frames = lcstate.frames;
 	const_data_ptr_t gstate_p = nullptr;
-	if (gstate) {
-		auto &gcstate = gstate->Cast<WindowCustomAggregatorState>();
-		gstate_p = gcstate.state.data();
+	auto &gcsink = gsink.Cast<WindowCustomAggregatorGlobalState>();
+	if (gcsink.gcstate) {
+		gstate_p = gcsink.gcstate->state.data();
 	}
 
 	EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) {
 		// Extract the range
 		AggregateInputData aggr_input_data(aggr.GetFunctionData(), lstate.allocator);
-		aggr.function.window(aggr_input_data, *partition_input, gstate_p, lcstate.state.data(), frames, result, i);
+		aggr.function.window(aggr_input_data, *gcsink.partition_input, gstate_p, lcstate.state.data(), frames, result,
+		                     i);
 	});
 }
 
 //===--------------------------------------------------------------------===//
 // WindowNaiveAggregator
 //===--------------------------------------------------------------------===//
-WindowNaiveAggregator::WindowNaiveAggregator(AggregateObject aggr, const LogicalType &result_type,
-                                             const WindowExcludeMode exclude_mode_p, idx_t partition_count)
-    : WindowAggregator(std::move(aggr), result_type, exclude_mode_p, partition_count) {
+WindowNaiveAggregator::WindowNaiveAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types,
+                                             const LogicalType &result_type, const WindowExcludeMode exclude_mode)
+    : WindowAggregator(std::move(aggr), arg_types, result_type, exclude_mode) {
 }
 
 WindowNaiveAggregator::~WindowNaiveAggregator() {
@@ -405,44 +630,47 @@ WindowNaiveAggregator::~WindowNaiveAggregator() {
 class WindowNaiveState : public WindowAggregatorState {
 public:
 	struct HashRow {
-		explicit HashRow(WindowNaiveState &state) : state(state) {
+		HashRow(WindowNaiveState &state, const DataChunk &inputs) : state(state), inputs(inputs) {
 		}
 
 		size_t operator()(const idx_t &i) const {
-			return state.Hash(i);
+			return state.Hash(inputs, i);
 		}
 
 		WindowNaiveState &state;
+		const DataChunk &inputs;
 	};
 
 	struct EqualRow {
-		explicit EqualRow(WindowNaiveState &state) : state(state) {
+		EqualRow(WindowNaiveState &state, const DataChunk &inputs) : state(state), inputs(inputs) {
 		}
 
 		bool operator()(const idx_t &lhs, const idx_t &rhs) const {
-			return state.KeyEqual(lhs, rhs);
+			return state.KeyEqual(inputs, lhs, rhs);
 		}
 
 		WindowNaiveState &state;
+		const DataChunk &inputs;
 	};
 
 	using RowSet = std::unordered_set<idx_t, HashRow, EqualRow>;
 
-	explicit WindowNaiveState(const WindowNaiveAggregator &gstate);
+	explicit WindowNaiveState(const WindowNaiveAggregator &gsink);
 
-	void Evaluate(const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx);
+	void Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx);
 
 protected:
 	//! Flush the accumulated intermediate states into the result states
-	void FlushStates();
+	void FlushStates(const WindowAggregatorGlobalState &gsink);
 
 	//! Hashes a value for the hash table
-	size_t Hash(idx_t rid);
+	size_t Hash(const DataChunk &inputs, idx_t rid);
 	//! Compares two values for the hash table
-	bool KeyEqual(const idx_t &lhs, const idx_t &rhs);
+	bool KeyEqual(const DataChunk &inputs, const idx_t &lhs, const idx_t &rhs);
 
 	//! The global state
-	const WindowNaiveAggregator &gstate;
+	const WindowNaiveAggregator &aggregator;
 	//! Data pointer that contains a vector of states, used for row aggregation
 	vector<data_t> state;
 	//! Reused result state container for the aggregate
@@ -459,21 +687,12 @@ protected:
 	SubFrames frames;
 	//! The optional hash table used for DISTINCT
 	Vector hashes;
-	HashRow hash_row;
-	EqualRow equal_row;
-	RowSet row_set;
 };
 
-WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &gstate)
-    : gstate(gstate), state(gstate.state_size * STANDARD_VECTOR_SIZE), statef(LogicalType::POINTER),
-      statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH), hash_row(*this), equal_row(*this),
-      row_set(STANDARD_VECTOR_SIZE, hash_row, equal_row) {
-	InitSubFrames(frames, gstate.exclude_mode);
-
-	auto &inputs = gstate.GetInputs();
-	if (inputs.ColumnCount() > 0) {
-		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
-	}
+WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p)
+    : aggregator(aggregator_p), state(aggregator.state_size * STANDARD_VECTOR_SIZE), statef(LogicalType::POINTER),
+      statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH) {
+	InitSubFrames(frames, aggregator.exclude_mode);
 
 	update_sel.Initialize();
 
@@ -485,28 +704,26 @@ WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &gstate)
 	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
 	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
 		fdata[i] = state_ptr;
-		state_ptr += gstate.state_size;
+		state_ptr += aggregator.state_size;
 	}
 }
 
-void WindowNaiveState::FlushStates() {
+void WindowNaiveState::FlushStates(const WindowAggregatorGlobalState &gsink) {
 	if (!flush_count) {
 		return;
 	}
 
-	auto &inputs = gstate.GetInputs();
+	auto &inputs = gsink.inputs;
 	leaves.Slice(inputs, update_sel, flush_count);
 
-	auto &aggr = gstate.aggr;
+	auto &aggr = aggregator.aggr;
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 	aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), statep, flush_count);
 
 	flush_count = 0;
 }
 
-size_t WindowNaiveState::Hash(idx_t rid) {
-	auto &inputs = gstate.GetInputs();
-
+size_t WindowNaiveState::Hash(const DataChunk &inputs, idx_t rid) {
 	auto s = UnsafeNumericCast<sel_t>(rid);
 	SelectionVector sel(&s);
 	leaves.Slice(inputs, sel, 1);
@@ -515,9 +732,7 @@ size_t WindowNaiveState::Hash(idx_t rid) {
 	return *FlatVector::GetData<hash_t>(hashes);
 }
 
-bool WindowNaiveState::KeyEqual(const idx_t &lhs, const idx_t &rhs) {
-	auto &inputs = gstate.GetInputs();
-
+bool WindowNaiveState::KeyEqual(const DataChunk &inputs, const idx_t &lhs, const idx_t &rhs) {
 	auto l = UnsafeNumericCast<sel_t>(lhs);
 	SelectionVector lsel(&l);
 
@@ -538,16 +753,26 @@ bool WindowNaiveState::KeyEqual(const idx_t &lhs, const idx_t &rhs) {
 	return true;
 }
 
-void WindowNaiveState::Evaluate(const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) {
-	auto &aggr = gstate.aggr;
-	auto &filter_mask = gstate.GetFilterMask();
+void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result,
+                                idx_t count, idx_t row_idx) {
+	auto &aggr = aggregator.aggr;
+	auto &filter_mask = gsink.filter_mask;
+	auto &inputs = gsink.inputs;
+
+	if (leaves.ColumnCount() == 0 && inputs.ColumnCount() > 0) {
+		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
+	}
 
 	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
 	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
 
-	EvaluateSubFrames(bounds, gstate.exclude_mode, count, row_idx, frames, [&](idx_t rid) {
+	HashRow hash_row(*this, inputs);
+	EqualRow equal_row(*this, inputs);
+	RowSet row_set(STANDARD_VECTOR_SIZE, hash_row, equal_row);
+
+	EvaluateSubFrames(bounds, aggregator.exclude_mode, count, row_idx, frames, [&](idx_t rid) {
 		auto agg_state = fdata[rid];
-		aggr.function.initialize(agg_state);
+		aggr.function.initialize(aggr.function, agg_state);
 
 		//	Just update the aggregate with the unfiltered input rows
 		row_set.clear();
@@ -565,14 +790,14 @@ void WindowNaiveState::Evaluate(const DataChunk &bounds, Vector &result, idx_t c
 				pdata[flush_count] = agg_state;
 				update_sel[flush_count++] = UnsafeNumericCast<sel_t>(f);
 				if (flush_count >= STANDARD_VECTOR_SIZE) {
-					FlushStates();
+					FlushStates(gsink);
 				}
 			}
 		}
 	});
 
 	//	Flush the final states
-	FlushStates();
+	FlushStates(gsink);
 
 	//	Finalise the result aggregates and write to the result
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
@@ -584,55 +809,57 @@ void WindowNaiveState::Evaluate(const DataChunk &bounds, Vector &result, idx_t c
 	}
 }
 
-unique_ptr<WindowAggregatorState> WindowNaiveAggregator::GetLocalState() const {
+unique_ptr<WindowAggregatorState> WindowNaiveAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
 	return make_uniq<WindowNaiveState>(*this);
 }
 
-void WindowNaiveAggregator::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result,
-                                     idx_t count, idx_t row_idx) const {
-	auto &ldstate = lstate.Cast<WindowNaiveState>();
-	ldstate.Evaluate(bounds, result, count, row_idx);
+void WindowNaiveAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                     const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
+	const auto &gnstate = gsink.Cast<WindowAggregatorGlobalState>();
+	auto &lnstate = lstate.Cast<WindowNaiveState>();
+	lnstate.Evaluate(gnstate, bounds, result, count, row_idx);
 }
 
 //===--------------------------------------------------------------------===//
 // WindowSegmentTree
 //===--------------------------------------------------------------------===//
-WindowSegmentTree::WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, WindowAggregationMode mode_p,
-                                     const WindowExcludeMode exclude_mode_p, idx_t count)
-    : WindowAggregator(std::move(aggr), result_type, exclude_mode_p, count), internal_nodes(0), mode(mode_p) {
-}
+class WindowSegmentTreeGlobalState : public WindowAggregatorGlobalState {
+public:
+	using AtomicCounters = vector<std::atomic<idx_t>>;
 
-void WindowSegmentTree::Finalize(const FrameStats &stats) {
-	WindowAggregator::Finalize(stats);
+	WindowSegmentTreeGlobalState(const WindowSegmentTree &aggregator, idx_t group_count);
 
-	gstate = GetLocalState();
-	if (inputs.ColumnCount() > 0) {
-		if (aggr.function.combine && UseCombineAPI()) {
-			ConstructTree();
-		}
+	ArenaAllocator &CreateTreeAllocator() {
+		lock_guard<mutex> tree_lock(lock);
+		tree_allocators.emplace_back(make_uniq<ArenaAllocator>(Allocator::DefaultAllocator()));
+		return *tree_allocators.back();
 	}
-}
 
-WindowSegmentTree::~WindowSegmentTree() {
-	if (!aggr.function.destructor || !gstate) {
-		// nothing to destroy
-		return;
-	}
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
-	// call the destructor for all the intermediate states
-	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
-	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);
-		if (count == STANDARD_VECTOR_SIZE) {
-			aggr.function.destructor(addresses, aggr_input_data, count);
-			count = 0;
-		}
-	}
-	if (count > 0) {
-		aggr.function.destructor(addresses, aggr_input_data, count);
-	}
+	//! The owning aggregator
+	const WindowSegmentTree &tree;
+	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
+	WindowAggregateStates levels_flat_native;
+	//! For each level, the starting location in the levels_flat_native array
+	vector<idx_t> levels_flat_start;
+	//! The level being built (read)
+	std::atomic<idx_t> build_level;
+	//! The number of entries started so far at each level
+	unique_ptr<AtomicCounters> build_started;
+	//! The number of entries completed so far at each level
+	unique_ptr<AtomicCounters> build_completed;
+	//! The tree allocators.
+	//! We need to hold onto them for the tree lifetime,
+	//! not the lifetime of the local state that constructed part of the tree
+	vector<unique_ptr<ArenaAllocator>> tree_allocators;
+
+	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
+	static constexpr idx_t TREE_FANOUT = 16;
+};
+
+WindowSegmentTree::WindowSegmentTree(AggregateObject aggr, const vector<LogicalType> &arg_types,
+                                     const LogicalType &result_type, WindowAggregationMode mode_p,
+                                     const WindowExcludeMode exclude_mode_p)
+    : WindowAggregator(std::move(aggr), arg_types, result_type, exclude_mode_p), mode(mode_p) {
 }
 
 class WindowSegmentTreePart {
@@ -643,7 +870,7 @@ public:
 	enum FramePart : uint8_t { FULL = 0, LEFT = 1, RIGHT = 2 };
 
 	WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr, const DataChunk &inputs,
-	                      const ValidityMask &filter_mask);
+	                      const ValidityArray &filter_mask);
 	~WindowSegmentTreePart();
 
 	unique_ptr<WindowSegmentTreePart> Copy() const {
@@ -652,23 +879,23 @@ public:
 
 	void FlushStates(bool combining);
 	void ExtractFrame(idx_t begin, idx_t end, data_ptr_t current_state);
-	void WindowSegmentValue(const WindowSegmentTree &tree, idx_t l_idx, idx_t begin, idx_t end,
+	void WindowSegmentValue(const WindowSegmentTreeGlobalState &tree, idx_t l_idx, idx_t begin, idx_t end,
 	                        data_ptr_t current_state);
 	//! Writes result and calls destructors
 	void Finalize(Vector &result, idx_t count);
 
 	void Combine(WindowSegmentTreePart &other, idx_t count);
 
-	void Evaluate(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends, Vector &result, idx_t count,
-	              idx_t row_idx, FramePart frame_part);
+	void Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, Vector &result,
+	              idx_t count, idx_t row_idx, FramePart frame_part);
 
 protected:
 	//! Initialises the accumulation state vector (statef)
 	void Initialize(idx_t count);
 	//! Accumulate upper tree levels
-	void EvaluateUpperLevels(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends, idx_t count,
-	                         idx_t row_idx, FramePart frame_part);
-	void EvaluateLeaves(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends, idx_t count,
+	void EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends,
+	                         idx_t count, idx_t row_idx, FramePart frame_part);
+	void EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, idx_t count,
 	                    idx_t row_idx, FramePart frame_part, FramePart leaf_part);
 
 public:
@@ -681,7 +908,7 @@ public:
 	//! The partition arguments
 	const DataChunk &inputs;
 	//! The filtered rows in inputs
-	const ValidityMask &filter_mask;
+	const ValidityArray &filter_mask;
 	//! The size of a single aggregate state
 	const idx_t state_size;
 	//! Data pointer that contains a vector of states, used for intermediate window segment aggregation
@@ -704,28 +931,41 @@ public:
 
 class WindowSegmentTreeState : public WindowAggregatorState {
 public:
-	WindowSegmentTreeState(const AggregateObject &aggr, const DataChunk &inputs, const ValidityMask &filter_mask)
-	    : aggr(aggr), inputs(inputs), filter_mask(filter_mask), part(allocator, aggr, inputs, filter_mask) {
+	WindowSegmentTreeState() {
 	}
 
-	//! The aggregate function
-	const AggregateObject &aggr;
-	//! The aggregate function
-	const DataChunk &inputs;
-	//! The filtered rows in inputs
-	const ValidityMask &filter_mask;
+	void Finalize(WindowSegmentTreeGlobalState &gstate);
+	void Evaluate(const WindowSegmentTreeGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx);
 	//! The left (default) segment tree part
-	WindowSegmentTreePart part;
+	unique_ptr<WindowSegmentTreePart> part;
 	//! The right segment tree part (for EXCLUDE)
 	unique_ptr<WindowSegmentTreePart> right_part;
 };
 
+void WindowSegmentTree::Finalize(WindowAggregatorState &gsink, WindowAggregatorState &lstate, const FrameStats &stats) {
+
+	auto &gasink = gsink.Cast<WindowSegmentTreeGlobalState>();
+	auto &inputs = gasink.inputs;
+
+	WindowAggregator::Finalize(gsink, lstate, stats);
+
+	if (inputs.ColumnCount() > 0) {
+		if (aggr.function.combine && UseCombineAPI()) {
+			lstate.Cast<WindowSegmentTreeState>().Finalize(gasink);
+		}
+	}
+
+	++gasink.finalized;
+}
+
 WindowSegmentTreePart::WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr,
-                                             const DataChunk &inputs, const ValidityMask &filter_mask)
+                                             const DataChunk &inputs, const ValidityArray &filter_mask)
     : allocator(allocator), aggr(aggr),
       order_insensitive(aggr.function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT), inputs(inputs),
-      filter_mask(filter_mask), state_size(aggr.function.state_size()), state(state_size * STANDARD_VECTOR_SIZE),
-      statep(LogicalType::POINTER), statel(LogicalType::POINTER), statef(LogicalType::POINTER), flush_count(0) {
+      filter_mask(filter_mask), state_size(aggr.function.state_size(aggr.function)),
+      state(state_size * STANDARD_VECTOR_SIZE), statep(LogicalType::POINTER), statel(LogicalType::POINTER),
+      statef(LogicalType::POINTER), flush_count(0) {
 	if (inputs.ColumnCount() > 0) {
 		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
 		filter_sel.Initialize();
@@ -746,8 +986,13 @@ WindowSegmentTreePart::WindowSegmentTreePart(ArenaAllocator &allocator, const Ag
 WindowSegmentTreePart::~WindowSegmentTreePart() {
 }
 
-unique_ptr<WindowAggregatorState> WindowSegmentTree::GetLocalState() const {
-	return make_uniq<WindowSegmentTreeState>(aggr, inputs, filter_mask);
+unique_ptr<WindowAggregatorState> WindowSegmentTree::GetGlobalState(idx_t group_count,
+                                                                    const ValidityMask &partition_mask) const {
+	return make_uniq<WindowSegmentTreeGlobalState>(*this, group_count);
+}
+
+unique_ptr<WindowAggregatorState> WindowSegmentTree::GetLocalState(const WindowAggregatorState &gstate) const {
+	return make_uniq<WindowSegmentTreeState>();
 }
 
 void WindowSegmentTreePart::FlushStates(bool combining) {
@@ -800,8 +1045,8 @@ void WindowSegmentTreePart::ExtractFrame(idx_t begin, idx_t end, data_ptr_t stat
 	}
 }
 
-void WindowSegmentTreePart::WindowSegmentValue(const WindowSegmentTree &tree, idx_t l_idx, idx_t begin, idx_t end,
-                                               data_ptr_t state_ptr) {
+void WindowSegmentTreePart::WindowSegmentValue(const WindowSegmentTreeGlobalState &tree, idx_t l_idx, idx_t begin,
+                                               idx_t end, data_ptr_t state_ptr) {
 	D_ASSERT(begin <= end);
 	if (begin == end || inputs.ColumnCount() == 0) {
 		return;
@@ -812,9 +1057,9 @@ void WindowSegmentTreePart::WindowSegmentValue(const WindowSegmentTree &tree, id
 		ExtractFrame(begin, end, state_ptr);
 	} else {
 		// find out where the states begin
-		auto begin_ptr = tree.levels_flat_native.get() + state_size * (begin + tree.levels_flat_start[l_idx - 1]);
+		auto begin_ptr = tree.levels_flat_native.GetStatePtr(begin + tree.levels_flat_start[l_idx - 1]);
 		// set up a vector of pointers that point towards the set of states
-		auto ldata = FlatVector::GetData<data_ptr_t>(statel);
+		auto ldata = FlatVector::GetData<const_data_ptr_t>(statel);
 		auto pdata = FlatVector::GetData<data_ptr_t>(statep);
 		for (idx_t i = 0; i < count; i++) {
 			pdata[flush_count] = state_ptr;
@@ -837,20 +1082,12 @@ void WindowSegmentTreePart::Finalize(Vector &result, idx_t count) {
 	}
 }
 
-void WindowSegmentTree::ConstructTree() {
-	D_ASSERT(inputs.ColumnCount() > 0);
+WindowSegmentTreeGlobalState::WindowSegmentTreeGlobalState(const WindowSegmentTree &aggregator, idx_t group_count)
+    : WindowAggregatorGlobalState(aggregator, group_count), tree(aggregator), levels_flat_native(aggregator.aggr) {
 
-	//	Use a temporary scan state to build the tree
-	auto &gtstate = gstate->Cast<WindowSegmentTreeState>().part;
+	D_ASSERT(inputs.ColumnCount() > 0);
 
 	// compute space required to store internal nodes of segment tree
-	internal_nodes = 0;
-	idx_t level_nodes = inputs.size();
-	do {
-		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
-		internal_nodes += level_nodes;
-	} while (level_nodes > 1);
-	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state_size);
 	levels_flat_start.push_back(0);
 
 	idx_t levels_flat_offset = 0;
@@ -861,12 +1098,6 @@ void WindowSegmentTree::ConstructTree() {
 	while ((level_size =
 	            (level_current == 0 ? inputs.size() : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
 		for (idx_t pos = 0; pos < level_size; pos += TREE_FANOUT) {
-			// compute the aggregate for this entry in the segment tree
-			data_ptr_t state_ptr = levels_flat_native.get() + (levels_flat_offset * state_size);
-			aggr.function.initialize(state_ptr);
-			gtstate.WindowSegmentValue(*this, level_current, pos, MinValue(level_size, pos + TREE_FANOUT), state_ptr);
-			gtstate.FlushStates(level_current > 0);
-
 			levels_flat_offset++;
 		}
 
@@ -876,46 +1107,120 @@ void WindowSegmentTree::ConstructTree() {
 
 	// Corner case: single element in the window
 	if (levels_flat_offset == 0) {
-		aggr.function.initialize(levels_flat_native.get());
+		++levels_flat_offset;
+	}
+
+	levels_flat_native.Initialize(levels_flat_offset);
+
+	// Start by building from the bottom level
+	build_level = 0;
+
+	build_started = make_uniq<AtomicCounters>(levels_flat_start.size());
+	for (auto &counter : *build_started) {
+		counter = 0;
+	}
+
+	build_completed = make_uniq<AtomicCounters>(levels_flat_start.size());
+	for (auto &counter : *build_completed) {
+		counter = 0;
 	}
 }
 
-void WindowSegmentTree::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-                                 idx_t row_idx) const {
+void WindowSegmentTreeState::Finalize(WindowSegmentTreeGlobalState &gstate) {
+	//	Single part for constructing the tree
+	auto &inputs = gstate.inputs;
+	auto &tree = gstate.tree;
+	auto &filter_mask = gstate.filter_mask;
+	WindowSegmentTreePart gtstate(gstate.CreateTreeAllocator(), tree.aggr, inputs, filter_mask);
+
+	auto &levels_flat_native = gstate.levels_flat_native;
+	const auto &levels_flat_start = gstate.levels_flat_start;
+	// iterate over the levels of the segment tree
+	for (;;) {
+		const idx_t level_current = gstate.build_level.load();
+		if (level_current >= levels_flat_start.size()) {
+			break;
+		}
+
+		// level 0 is data itself
+		const auto level_size =
+		    (level_current == 0 ? inputs.size()
+		                        : levels_flat_start[level_current] - levels_flat_start[level_current - 1]);
+		if (level_size <= 1) {
+			break;
+		}
+		const idx_t build_count = (level_size + gstate.TREE_FANOUT - 1) / gstate.TREE_FANOUT;
+
+		// Build the next fan-in
+		const idx_t build_idx = (*gstate.build_started).at(level_current)++;
+		if (build_idx >= build_count) {
+			//	Nothing left at this level, so wait until other threads are done.
+			//	Since we are only building TREE_FANOUT values at a time, this will be quick.
+			while (level_current == gstate.build_level.load()) {
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
+			}
+			continue;
+		}
+
+		// compute the aggregate for this entry in the segment tree
+		const idx_t pos = build_idx * gstate.TREE_FANOUT;
+		const idx_t levels_flat_offset = levels_flat_start[level_current] + build_idx;
+		auto state_ptr = levels_flat_native.GetStatePtr(levels_flat_offset);
+		gtstate.WindowSegmentValue(gstate, level_current, pos, MinValue(level_size, pos + gstate.TREE_FANOUT),
+		                           state_ptr);
+		gtstate.FlushStates(level_current > 0);
+
+		//	If that was the last one, mark the level as complete.
+		const idx_t build_complete = ++(*gstate.build_completed).at(level_current);
+		if (build_complete == build_count) {
+			gstate.build_level++;
+			continue;
+		}
+	}
+}
 
+void WindowSegmentTree::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                 const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
+	const auto &gtstate = gsink.Cast<WindowSegmentTreeGlobalState>();
 	auto &ltstate = lstate.Cast<WindowSegmentTreeState>();
+	ltstate.Evaluate(gtstate, bounds, result, count, row_idx);
+}
+
+void WindowSegmentTreeState::Evaluate(const WindowSegmentTreeGlobalState &gtstate, const DataChunk &bounds,
+                                      Vector &result, idx_t count, idx_t row_idx) {
 	auto window_begin = FlatVector::GetData<const idx_t>(bounds.data[WINDOW_BEGIN]);
 	auto window_end = FlatVector::GetData<const idx_t>(bounds.data[WINDOW_END]);
 	auto peer_begin = FlatVector::GetData<const idx_t>(bounds.data[PEER_BEGIN]);
 	auto peer_end = FlatVector::GetData<const idx_t>(bounds.data[PEER_END]);
 
-	auto &part = ltstate.part;
-	if (exclude_mode != WindowExcludeMode::NO_OTHER) {
+	if (!part) {
+		part =
+		    make_uniq<WindowSegmentTreePart>(allocator, gtstate.aggregator.aggr, gtstate.inputs, gtstate.filter_mask);
+	}
+
+	if (gtstate.aggregator.exclude_mode != WindowExcludeMode::NO_OTHER) {
 		// 1. evaluate the tree left of the excluded part
-		part.Evaluate(*this, window_begin, peer_begin, result, count, row_idx, WindowSegmentTreePart::LEFT);
+		part->Evaluate(gtstate, window_begin, peer_begin, result, count, row_idx, WindowSegmentTreePart::LEFT);
 
 		// 2. set up a second state for the right of the excluded part
-		if (!ltstate.right_part) {
-			ltstate.right_part = part.Copy();
+		if (!right_part) {
+			right_part = part->Copy();
 		}
-		auto &right_part = *ltstate.right_part;
 
 		// 3. evaluate the tree right of the excluded part
-		right_part.Evaluate(*this, peer_end, window_end, result, count, row_idx, WindowSegmentTreePart::RIGHT);
+		right_part->Evaluate(gtstate, peer_end, window_end, result, count, row_idx, WindowSegmentTreePart::RIGHT);
 
 		// 4. combine the buffer state into the Segment Tree State
-		part.Combine(right_part, count);
+		part->Combine(*right_part, count);
 	} else {
-		part.Evaluate(*this, window_begin, window_end, result, count, row_idx, WindowSegmentTreePart::FULL);
+		part->Evaluate(gtstate, window_begin, window_end, result, count, row_idx, WindowSegmentTreePart::FULL);
 	}
 
-	part.Finalize(result, count);
+	part->Finalize(result, count);
 }
 
-void WindowSegmentTreePart::Evaluate(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends,
+void WindowSegmentTreePart::Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends,
                                      Vector &result, idx_t count, idx_t row_idx, FramePart frame_part) {
-	D_ASSERT(aggr.function.combine && tree.UseCombineAPI());
-
 	Initialize(count);
 
 	if (order_insensitive) {
@@ -936,15 +1241,15 @@ void WindowSegmentTreePart::Initialize(idx_t count) {
 	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
 	for (idx_t rid = 0; rid < count; ++rid) {
 		auto state_ptr = fdata[rid];
-		aggr.function.initialize(state_ptr);
+		aggr.function.initialize(aggr.function, state_ptr);
 	}
 }
 
-void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends,
-                                                idx_t count, idx_t row_idx, FramePart frame_part) {
+void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins,
+                                                const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part) {
 	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
 
-	const auto exclude_mode = tree.exclude_mode;
+	const auto exclude_mode = tree.tree.exclude_mode;
 	const bool begin_on_curr_row = frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
 	const bool end_on_curr_row = frame_part == FramePart::LEFT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
 
@@ -1034,8 +1339,9 @@ void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTree &tree, c
 	FlushStates(true);
 }
 
-void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTree &tree, const idx_t *begins, const idx_t *ends,
-                                           idx_t count, idx_t row_idx, FramePart frame_part, FramePart leaf_part) {
+void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins,
+                                           const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part,
+                                           FramePart leaf_part) {
 
 	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
 
@@ -1044,7 +1350,7 @@ void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTree &tree, const
 	// The current row is the leftmost value of the right hand side.
 	const bool compute_left = leaf_part != FramePart::RIGHT;
 	const bool compute_right = leaf_part != FramePart::LEFT;
-	const auto exclude_mode = tree.exclude_mode;
+	const auto exclude_mode = tree.tree.exclude_mode;
 	const bool begin_on_curr_row = frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
 	const bool end_on_curr_row = frame_part == FramePart::LEFT && exclude_mode == WindowExcludeMode::CURRENT_ROW;
 	// with EXCLUDE TIES, in addition to the frame part right of the peer group's end, we also need to consider the
@@ -1087,81 +1393,236 @@ void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTree &tree, const
 //===--------------------------------------------------------------------===//
 // WindowDistinctAggregator
 //===--------------------------------------------------------------------===//
-WindowDistinctAggregator::WindowDistinctAggregator(AggregateObject aggr, const LogicalType &result_type,
-                                                   const WindowExcludeMode exclude_mode_p, idx_t count,
-                                                   ClientContext &context)
-    : WindowAggregator(std::move(aggr), result_type, exclude_mode_p, count), context(context),
-      allocator(Allocator::DefaultAllocator()) {
+WindowDistinctAggregator::WindowDistinctAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types,
+                                                   const LogicalType &result_type,
+                                                   const WindowExcludeMode exclude_mode_p, ClientContext &context)
+    : WindowAggregator(std::move(aggr), arg_types, result_type, exclude_mode_p), context(context) {
+}
+
+class WindowDistinctAggregatorLocalState;
+
+class WindowDistinctAggregatorGlobalState;
+
+class WindowDistinctSortTree : public MergeSortTree<idx_t, idx_t> {
+public:
+	// prev_idx, input_idx
+	using ZippedTuple = std::tuple<idx_t, idx_t>;
+	using ZippedElements = vector<ZippedTuple>;
+
+	explicit WindowDistinctSortTree(WindowDistinctAggregatorGlobalState &gdastate, idx_t count) : gdastate(gdastate) {
+		//	Set up for parallel build
+		build_level = 0;
+		build_complete = 0;
+		build_run = 0;
+		build_run_length = 1;
+		build_num_runs = count;
+	}
+
+	void Build(WindowDistinctAggregatorLocalState &ldastate);
+
+protected:
+	bool TryNextRun(idx_t &level_idx, idx_t &run_idx);
+	void BuildRun(idx_t level_nr, idx_t i, WindowDistinctAggregatorLocalState &ldastate);
 
+	WindowDistinctAggregatorGlobalState &gdastate;
+};
+
+class WindowDistinctAggregatorGlobalState : public WindowAggregatorGlobalState {
+public:
+	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
+	using ZippedTuple = WindowDistinctSortTree::ZippedTuple;
+	using ZippedElements = WindowDistinctSortTree::ZippedElements;
+
+	WindowDistinctAggregatorGlobalState(const WindowDistinctAggregator &aggregator, idx_t group_count);
+
+	//! Compute the block starts
+	void MeasurePayloadBlocks();
+	//! Patch up the previous index block boundaries
+	void PatchPrevIdcs();
+	bool TryPrepareNextStage(WindowDistinctAggregatorLocalState &lstate);
+
+	//	Single threaded sorting for now
+	ClientContext &context;
+	idx_t memory_per_thread;
+
+	//! Finalize guard
+	mutex lock;
+	//! Finalize stage
+	atomic<PartitionSortStage> stage;
+	//! Tasks launched
+	idx_t total_tasks = 0;
+	//! Tasks launched
+	idx_t tasks_assigned = 0;
+	//! Tasks landed
+	mutable atomic<idx_t> tasks_completed;
+
+	//! The sorted payload data types (partition index)
+	vector<LogicalType> payload_types;
+	//! The aggregate arguments + partition index
+	vector<LogicalType> sort_types;
+
+	//! Sorting operations
+	GlobalSortStatePtr global_sort;
+	//! The block starts (the scanner doesn't know this) plus the total count
+	vector<idx_t> block_starts;
+
+	//! The block boundary seconds
+	mutable ZippedElements seconds;
+	//! The MST with the distinct back pointers
+	mutable MergeSortTree<ZippedTuple> zipped_tree;
+	//! The merge sort tree for the aggregate.
+	WindowDistinctSortTree merge_sort_tree;
+
+	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
+	WindowAggregateStates levels_flat_native;
+	//! For each level, the starting location in the levels_flat_native array
+	vector<idx_t> levels_flat_start;
+};
+
+WindowDistinctAggregatorGlobalState::WindowDistinctAggregatorGlobalState(const WindowDistinctAggregator &aggregator,
+                                                                         idx_t group_count)
+    : WindowAggregatorGlobalState(aggregator, group_count), context(aggregator.context),
+      stage(PartitionSortStage::INIT), tasks_completed(0), merge_sort_tree(*this, group_count),
+      levels_flat_native(aggregator.aggr) {
 	payload_types.emplace_back(LogicalType::UBIGINT);
-	payload_chunk.Initialize(Allocator::DefaultAllocator(), payload_types);
-}
 
-WindowDistinctAggregator::~WindowDistinctAggregator() {
-	if (!aggr.function.destructor) {
-		// nothing to destroy
-		return;
+	//	1:	functionComputePrevIdcs(𝑖𝑛)
+	//	2:		sorted ← []
+	//	We sort the aggregate arguments and use the partition index as a tie-breaker.
+	//	TODO: Use a hash table?
+	sort_types = aggregator.arg_types;
+	for (const auto &type : payload_types) {
+		sort_types.emplace_back(type);
 	}
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	// call the destructor for all the intermediate states
-	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
-	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);
-		if (count == STANDARD_VECTOR_SIZE) {
-			aggr.function.destructor(addresses, aggr_input_data, count);
-			count = 0;
-		}
+
+	vector<BoundOrderByNode> orders;
+	for (const auto &type : sort_types) {
+		auto expr = make_uniq<BoundConstantExpression>(Value(type));
+		orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(expr)));
 	}
-	if (count > 0) {
-		aggr.function.destructor(addresses, aggr_input_data, count);
+
+	RowLayout payload_layout;
+	payload_layout.Initialize(payload_types);
+
+	global_sort = make_uniq<GlobalSortState>(BufferManager::GetBufferManager(context), orders, payload_layout);
+
+	memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
+
+	//	6:	prevIdcs ← []
+	//	7:	prevIdcs[0] ← “-”
+	auto &prev_idcs = zipped_tree.Allocate(group_count);
+
+	//	To handle FILTER clauses we make the missing elements
+	//	point to themselves so they won't be counted.
+	for (idx_t i = 0; i < group_count; ++i) {
+		prev_idcs[i] = ZippedTuple(i + 1, i);
+	}
+
+	// compute space required to store aggregation states of merge sort tree
+	// this is one aggregate state per entry per level
+	idx_t internal_nodes = 0;
+	levels_flat_start.push_back(internal_nodes);
+	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
+		internal_nodes += zipped_tree.tree[level_nr].first.size();
+		levels_flat_start.push_back(internal_nodes);
+	}
+	levels_flat_native.Initialize(internal_nodes);
+
+	merge_sort_tree.tree.reserve(zipped_tree.tree.size());
+	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
+		auto &zipped_level = zipped_tree.tree[level_nr].first;
+		WindowDistinctSortTree::Elements level;
+		WindowDistinctSortTree::Offsets cascades;
+		level.resize(zipped_level.size());
+		merge_sort_tree.tree.emplace_back(std::move(level), std::move(cascades));
 	}
 }
 
-void WindowDistinctAggregator::Sink(DataChunk &arg_chunk, SelectionVector *filter_sel, idx_t filtered) {
-	WindowAggregator::Sink(arg_chunk, filter_sel, filtered);
+class WindowDistinctAggregatorLocalState : public WindowAggregatorState {
+public:
+	explicit WindowDistinctAggregatorLocalState(const WindowDistinctAggregatorGlobalState &aggregator);
+
+	void Sink(DataChunk &arg_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
+	void Sorted();
+	void ExecuteTask();
+	void Evaluate(const WindowDistinctAggregatorGlobalState &gdstate, const DataChunk &bounds, Vector &result,
+	              idx_t count, idx_t row_idx);
+
+	//! Thread-local sorting data
+	LocalSortState local_sort;
+	//! Finalize stage
+	PartitionSortStage stage = PartitionSortStage::INIT;
+	//! Finalize scan block index
+	idx_t block_idx;
+	//! Thread-local tree aggregation
+	Vector update_v;
+	Vector source_v;
+	Vector target_v;
+	DataChunk leaves;
+	SelectionVector sel;
 
-	//	We sort the arguments and use the partition index as a tie-breaker.
-	//	TODO: Use a hash table?
-	if (!global_sort) {
-		//	1:	functionComputePrevIdcs(𝑖𝑛)
-		//	2:		sorted ← []
-		vector<LogicalType> sort_types;
-		for (const auto &col : arg_chunk.data) {
-			sort_types.emplace_back(col.GetType());
-		}
+protected:
+	//! Flush the accumulated intermediate states into the result states
+	void FlushStates();
 
-		for (const auto &type : payload_types) {
-			sort_types.emplace_back(type);
-		}
+	//! The aggregator we are working with
+	const WindowDistinctAggregatorGlobalState &gastate;
+	DataChunk sort_chunk;
+	DataChunk payload_chunk;
+	//! Reused result state container for the window functions
+	WindowAggregateStates statef;
+	//! A vector of pointers to "state", used for buffering intermediate aggregates
+	Vector statep;
+	//! Reused state pointers for combining tree elements
+	Vector statel;
+	//! Count of buffered values
+	idx_t flush_count;
+	//! The frame boundaries, used for the window functions
+	SubFrames frames;
+};
 
-		vector<BoundOrderByNode> orders;
-		for (const auto &type : sort_types) {
-			auto expr = make_uniq<BoundConstantExpression>(Value(type));
-			orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(expr)));
-		}
+WindowDistinctAggregatorLocalState::WindowDistinctAggregatorLocalState(
+    const WindowDistinctAggregatorGlobalState &gastate)
+    : update_v(LogicalType::POINTER), source_v(LogicalType::POINTER), target_v(LogicalType::POINTER), gastate(gastate),
+      statef(gastate.aggregator.aggr), statep(LogicalType::POINTER), statel(LogicalType::POINTER), flush_count(0) {
+	InitSubFrames(frames, gastate.aggregator.exclude_mode);
+	payload_chunk.Initialize(Allocator::DefaultAllocator(), gastate.payload_types);
 
-		RowLayout payload_layout;
-		payload_layout.Initialize(payload_types);
+	auto &global_sort = gastate.global_sort;
+	local_sort.Initialize(*global_sort, global_sort->buffer_manager);
 
-		global_sort = make_uniq<GlobalSortState>(BufferManager::GetBufferManager(context), orders, payload_layout);
-		local_sort.Initialize(*global_sort, global_sort->buffer_manager);
+	sort_chunk.Initialize(Allocator::DefaultAllocator(), gastate.sort_types);
+	sort_chunk.data.back().Reference(payload_chunk.data[0]);
 
-		sort_chunk.Initialize(Allocator::DefaultAllocator(), sort_types);
-		sort_chunk.data.back().Reference(payload_chunk.data[0]);
-		payload_pos = 0;
-		memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
-	}
+	//! Input data chunk, used for leaf segment aggregation
+	leaves.Initialize(Allocator::DefaultAllocator(), gastate.inputs.GetTypes());
+	sel.Initialize();
+
+	gastate.locals++;
+}
+
+unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetGlobalState(idx_t group_count,
+                                                                           const ValidityMask &partition_mask) const {
+	return make_uniq<WindowDistinctAggregatorGlobalState>(*this, group_count);
+}
+
+void WindowDistinctAggregator::Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &arg_chunk,
+                                    idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
+	WindowAggregator::Sink(gsink, lstate, arg_chunk, input_idx, filter_sel, filtered);
 
+	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
+	ldstate.Sink(arg_chunk, input_idx, filter_sel, filtered);
+}
+
+void WindowDistinctAggregatorLocalState::Sink(DataChunk &arg_chunk, idx_t input_idx,
+                                              optional_ptr<SelectionVector> filter_sel, idx_t filtered) {
 	//	3: 	for i ← 0 to in.size do
 	//	4: 		sorted[i] ← (in[i], i)
 	const auto count = arg_chunk.size();
 	payload_chunk.Reset();
 	auto &sorted_vec = payload_chunk.data[0];
 	auto sorted = FlatVector::GetData<idx_t>(sorted_vec);
-	std::iota(sorted, sorted + count, payload_pos);
-	payload_pos += count;
+	std::iota(sorted, sorted + count, input_idx);
 
 	for (column_t c = 0; c < arg_chunk.ColumnCount(); ++c) {
 		sort_chunk.data[c].Reference(arg_chunk.data[c]);
@@ -1178,61 +1639,178 @@ void WindowDistinctAggregator::Sink(DataChunk &arg_chunk, SelectionVector *filte
 
 	local_sort.SinkChunk(sort_chunk, payload_chunk);
 
-	if (local_sort.SizeInBytes() > memory_per_thread) {
-		local_sort.Sort(*global_sort, true);
+	if (local_sort.SizeInBytes() > gastate.memory_per_thread) {
+		local_sort.Sort(*gastate.global_sort, true);
 	}
 }
 
-class WindowDistinctAggregator::DistinctSortTree : public MergeSortTree<idx_t, idx_t> {
-public:
-	// prev_idx, input_idx
-	using ZippedTuple = std::tuple<idx_t, idx_t>;
-	using ZippedElements = vector<ZippedTuple>;
+void WindowDistinctAggregatorLocalState::ExecuteTask() {
+	auto &global_sort = *gastate.global_sort;
+	switch (stage) {
+	case PartitionSortStage::INIT:
+		//	AddLocalState is thread-safe
+		global_sort.AddLocalState(local_sort);
+		break;
+	case PartitionSortStage::MERGE: {
+		MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
+		merge_sorter.PerformInMergeRound();
+		break;
+	}
+	case PartitionSortStage::SORTED:
+		Sorted();
+		break;
+	default:
+		break;
+	}
 
-	DistinctSortTree(ZippedElements &&prev_idcs, WindowDistinctAggregator &wda);
-};
+	++gastate.tasks_completed;
+}
 
-void WindowDistinctAggregator::Finalize(const FrameStats &stats) {
-	//	5: Sort sorted lexicographically increasing
-	global_sort->AddLocalState(local_sort);
-	global_sort->PrepareMergePhase();
-	while (global_sort->sorted_blocks.size() > 1) {
+void WindowDistinctAggregatorGlobalState::MeasurePayloadBlocks() {
+	const auto &blocks = global_sort->sorted_blocks[0]->payload_data->data_blocks;
+	idx_t count = 0;
+	for (const auto &block : blocks) {
+		block_starts.emplace_back(count);
+		count += block->count;
+	}
+	block_starts.emplace_back(count);
+}
+
+bool WindowDistinctAggregatorGlobalState::TryPrepareNextStage(WindowDistinctAggregatorLocalState &lstate) {
+	lock_guard<mutex> stage_guard(lock);
+
+	switch (stage.load()) {
+	case PartitionSortStage::INIT:
+		// Wait for all the local sorts to be processed
+		if (tasks_completed < locals) {
+			return false;
+		}
+		global_sort->PrepareMergePhase();
+		if (!(global_sort->sorted_blocks.size() / 2)) {
+			if (global_sort->sorted_blocks.empty()) {
+				lstate.stage = stage = PartitionSortStage::FINISHED;
+				return true;
+			}
+			MeasurePayloadBlocks();
+			seconds.resize(block_starts.size() - 1);
+			total_tasks = seconds.size();
+			tasks_completed = 0;
+			tasks_assigned = 0;
+			lstate.stage = stage = PartitionSortStage::SORTED;
+			lstate.block_idx = tasks_assigned++;
+			return true;
+		}
 		global_sort->InitializeMergeRound();
-		MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
-		merge_sorter.PerformInMergeRound();
+		lstate.stage = stage = PartitionSortStage::MERGE;
+		total_tasks = locals;
+		tasks_assigned = 1;
+		tasks_completed = 0;
+		return true;
+	case PartitionSortStage::MERGE:
+		if (tasks_assigned < total_tasks) {
+			lstate.stage = PartitionSortStage::MERGE;
+			++tasks_assigned;
+			return true;
+		} else if (tasks_completed < tasks_assigned) {
+			return false;
+		}
 		global_sort->CompleteMergeRound(true);
+		if (!(global_sort->sorted_blocks.size() / 2)) {
+			MeasurePayloadBlocks();
+			seconds.resize(block_starts.size() - 1);
+			total_tasks = seconds.size();
+			tasks_completed = 0;
+			tasks_assigned = 0;
+			lstate.stage = stage = PartitionSortStage::SORTED;
+			lstate.block_idx = tasks_assigned++;
+			return true;
+		}
+		global_sort->InitializeMergeRound();
+		lstate.stage = PartitionSortStage::MERGE;
+		total_tasks = locals;
+		tasks_assigned = 1;
+		tasks_completed = 0;
+		return true;
+	case PartitionSortStage::SORTED:
+		if (tasks_assigned < total_tasks) {
+			lstate.stage = PartitionSortStage::SORTED;
+			lstate.block_idx = tasks_assigned++;
+			return true;
+		} else if (tasks_completed < tasks_assigned) {
+			lstate.stage = PartitionSortStage::FINISHED;
+			// Sleep while other tasks finish
+			return false;
+		}
+		// Last task patches the boundaries
+		PatchPrevIdcs();
+		break;
+	default:
+		break;
 	}
 
-	DataChunk scan_chunk;
-	scan_chunk.Initialize(Allocator::DefaultAllocator(), payload_types);
+	lstate.stage = stage = PartitionSortStage::FINISHED;
 
-	auto scanner = make_uniq<PayloadScanner>(*global_sort);
-	const auto in_size = scanner->Remaining();
-	scanner->Scan(scan_chunk);
-	idx_t scan_idx = 0;
+	return true;
+}
 
-	//	6:	prevIdcs ← []
-	//	7:	prevIdcs[0] ← “-”
-	const auto count = inputs.size();
-	using ZippedTuple = DistinctSortTree::ZippedTuple;
-	DistinctSortTree::ZippedElements prev_idcs;
-	prev_idcs.resize(count);
+void WindowDistinctAggregator::Finalize(WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                        const FrameStats &stats) {
+	auto &gdsink = gsink.Cast<WindowDistinctAggregatorGlobalState>();
+	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
 
-	//	To handle FILTER clauses we make the missing elements
-	//	point to themselves so they won't be counted.
-	if (in_size < count) {
-		for (idx_t i = 0; i < count; ++i) {
-			prev_idcs[i] = ZippedTuple(i + 1, i);
+	//	5: Sort sorted lexicographically increasing
+	ldstate.ExecuteTask();
+
+	// Merge in parallel
+	while (gdsink.stage.load() != PartitionSortStage::FINISHED) {
+		if (gdsink.TryPrepareNextStage(ldstate)) {
+			ldstate.ExecuteTask();
+		} else {
+			std::this_thread::yield();
 		}
 	}
 
+	//	These are a parallel implementations,
+	//	so every thread can call them.
+	gdsink.zipped_tree.Build();
+	gdsink.merge_sort_tree.Build(ldstate);
+
+	++gdsink.finalized;
+}
+
+void WindowDistinctAggregatorLocalState::Sorted() {
+	using ZippedTuple = WindowDistinctAggregatorGlobalState::ZippedTuple;
+	auto &global_sort = gastate.global_sort;
+	auto &prev_idcs = gastate.zipped_tree.LowestLevel();
+	auto &aggregator = gastate.aggregator;
+	auto &scan_chunk = payload_chunk;
+
+	auto scanner = make_uniq<PayloadScanner>(*global_sort, block_idx);
+	const auto in_size = gastate.block_starts.at(block_idx + 1);
+	scanner->Scan(scan_chunk);
+	idx_t scan_idx = 0;
+
 	auto *input_idx = FlatVector::GetData<idx_t>(scan_chunk.data[0]);
-	auto i = input_idx[scan_idx++];
-	prev_idcs[i] = ZippedTuple(0, i);
+	idx_t i = 0;
 
 	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
 	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
-	auto prefix_layout = global_sort->sort_layout.GetPrefixComparisonLayout(sort_chunk.ColumnCount() - 1);
+	auto prefix_layout = global_sort->sort_layout.GetPrefixComparisonLayout(aggregator.arg_types.size());
+
+	const auto block_begin = gastate.block_starts.at(block_idx);
+	if (!block_begin) {
+		// First block, so set up initial sentinel
+		i = input_idx[scan_idx++];
+		prev_idcs[i] = ZippedTuple(0, i);
+		std::get<0>(gastate.seconds[block_idx]) = i;
+	} else {
+		// Move to the to end of the previous block
+		// so we can record the comparison result for the first row
+		curr.SetIndex(block_begin - 1);
+		prev.SetIndex(block_begin - 1);
+		scan_idx = 0;
+		std::get<0>(gastate.seconds[block_idx]) = input_idx[scan_idx];
+	}
 
 	//	8:	for i ← 1 to in.size do
 	for (++curr; curr.GetIndex() < in_size; ++curr, ++prev) {
@@ -1265,105 +1843,148 @@ void WindowDistinctAggregator::Finalize(const FrameStats &stats) {
 			prev_idcs[i] = ZippedTuple(0, i);
 		}
 	}
+
+	// Save the last value of i for patching up the block boundaries
+	std::get<1>(gastate.seconds[block_idx]) = i;
+}
+
+void WindowDistinctAggregatorGlobalState::PatchPrevIdcs() {
 	//	13:	return prevIdcs
 
-	merge_sort_tree = make_uniq<DistinctSortTree>(std::move(prev_idcs), *this);
+	// Patch up the indices at block boundaries
+	// (We don't need to patch block 0.)
+	auto &prev_idcs = zipped_tree.LowestLevel();
+	for (idx_t block_idx = 1; block_idx < seconds.size(); ++block_idx) {
+		// We only need to patch if the first index in the block
+		// was a back link to the previous block (10:)
+		auto i = std::get<0>(seconds.at(block_idx));
+		if (std::get<0>(prev_idcs[i])) {
+			auto second = std::get<1>(seconds.at(block_idx - 1));
+			prev_idcs[i] = ZippedTuple(second + 1, i);
+		}
+	}
+}
+
+bool WindowDistinctSortTree::TryNextRun(idx_t &level_idx, idx_t &run_idx) {
+	const auto fanout = FANOUT;
+
+	lock_guard<mutex> stage_guard(build_lock);
+
+	//	Verify we are not done
+	if (build_level >= tree.size()) {
+		return false;
+	}
+
+	// Finished with this level?
+	if (build_complete >= build_num_runs) {
+		auto &zipped_tree = gdastate.zipped_tree;
+		std::swap(tree[build_level].second, zipped_tree.tree[build_level].second);
+
+		++build_level;
+		if (build_level >= tree.size()) {
+			zipped_tree.tree.clear();
+			return false;
+		}
+
+		const auto count = LowestLevel().size();
+		build_run_length *= fanout;
+		build_num_runs = (count + build_run_length - 1) / build_run_length;
+		build_run = 0;
+		build_complete = 0;
+	}
+
+	// If all runs are in flight,
+	// yield until the next level is ready
+	if (build_run >= build_num_runs) {
+		return false;
+	}
+
+	level_idx = build_level;
+	run_idx = build_run++;
+
+	return true;
+}
+
+void WindowDistinctSortTree::Build(WindowDistinctAggregatorLocalState &ldastate) {
+	//	Fan in parent levels until we are at the top
+	//	Note that we don't build the top layer as that would just be all the data.
+	while (build_level.load() < tree.size()) {
+		idx_t level_idx;
+		idx_t run_idx;
+		if (TryNextRun(level_idx, run_idx)) {
+			BuildRun(level_idx, run_idx, ldastate);
+		} else {
+			std::this_thread::yield();
+		}
+	}
 }
 
-WindowDistinctAggregator::DistinctSortTree::DistinctSortTree(ZippedElements &&prev_idcs,
-                                                             WindowDistinctAggregator &wda) {
-	auto &inputs = wda.inputs;
-	auto &aggr = wda.aggr;
-	auto &allocator = wda.allocator;
-	const auto state_size = wda.state_size;
-	auto &internal_nodes = wda.internal_nodes;
-	auto &levels_flat_native = wda.levels_flat_native;
-	auto &levels_flat_start = wda.levels_flat_start;
+void WindowDistinctSortTree::BuildRun(idx_t level_nr, idx_t run_idx, WindowDistinctAggregatorLocalState &ldastate) {
+	auto &aggr = gdastate.aggregator.aggr;
+	auto &allocator = gdastate.allocator;
+	auto &inputs = gdastate.inputs;
+	auto &levels_flat_native = gdastate.levels_flat_native;
 
 	//! Input data chunk, used for leaf segment aggregation
-	DataChunk leaves;
-	leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
-	SelectionVector sel;
-	sel.Initialize();
+	auto &leaves = ldastate.leaves;
+	auto &sel = ldastate.sel;
 
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 
 	//! The states to update
-	Vector update_v(LogicalType::POINTER);
+	auto &update_v = ldastate.update_v;
 	auto updates = FlatVector::GetData<data_ptr_t>(update_v);
-	idx_t nupdate = 0;
 
-	Vector source_v(LogicalType::POINTER);
+	auto &source_v = ldastate.source_v;
 	auto sources = FlatVector::GetData<data_ptr_t>(source_v);
-	Vector target_v(LogicalType::POINTER);
+	auto &target_v = ldastate.target_v;
 	auto targets = FlatVector::GetData<data_ptr_t>(target_v);
-	idx_t ncombine = 0;
-
-	// compute space required to store aggregation states of merge sort tree
-	// this is one aggregate state per entry per level
-	MergeSortTree<ZippedTuple> zipped_tree(std::move(prev_idcs));
-	internal_nodes = 0;
-	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
-		internal_nodes += zipped_tree.tree[level_nr].first.size();
-	}
-	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state_size);
-	levels_flat_start.push_back(0);
-	idx_t levels_flat_offset = 0;
 
-	//	Walk the distinct value tree building the intermediate aggregates
-	tree.reserve(zipped_tree.tree.size());
-	idx_t level_width = 1;
-	for (idx_t level_nr = 0; level_nr < zipped_tree.tree.size(); ++level_nr) {
-		auto &zipped_level = zipped_tree.tree[level_nr].first;
-		vector<ElementType> level;
-		level.reserve(zipped_level.size());
-
-		for (idx_t i = 0; i < zipped_level.size(); i += level_width) {
-			//	Reset the combine state
-			data_ptr_t prev_state = nullptr;
-			auto next_limit = MinValue<idx_t>(zipped_level.size(), i + level_width);
-			for (auto j = i; j < next_limit; ++j) {
-				//	Initialise the next aggregate
-				auto curr_state = levels_flat_native.get() + (levels_flat_offset++ * state_size);
-				aggr.function.initialize(curr_state);
-
-				//	Update this state (if it matches)
-				const auto prev_idx = std::get<0>(zipped_level[j]);
-				level.emplace_back(prev_idx);
-				if (prev_idx < i + 1) {
-					updates[nupdate] = curr_state;
-					//	input_idx
-					sel[nupdate] = UnsafeNumericCast<sel_t>(std::get<1>(zipped_level[j]));
-					++nupdate;
-				}
+	auto &zipped_tree = gdastate.zipped_tree;
+	auto &zipped_level = zipped_tree.tree[level_nr].first;
+	auto &level = tree[level_nr].first;
 
-				//	Merge the previous state (if any)
-				if (prev_state) {
-					sources[ncombine] = prev_state;
-					targets[ncombine] = curr_state;
-					++ncombine;
-				}
-				prev_state = curr_state;
-
-				//	Flush the states if one is maxed out.
-				if (MaxValue<idx_t>(ncombine, nupdate) >= STANDARD_VECTOR_SIZE) {
-					//	Push the updates first so they propagate
-					leaves.Reference(inputs);
-					leaves.Slice(sel, nupdate);
-					aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), update_v, nupdate);
-					nupdate = 0;
-
-					//	Combine the states sequentially
-					aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
-					ncombine = 0;
-				}
-			}
+	//	Reset the combine state
+	idx_t nupdate = 0;
+	idx_t ncombine = 0;
+	data_ptr_t prev_state = nullptr;
+	idx_t i = run_idx * build_run_length;
+	auto next_limit = MinValue<idx_t>(zipped_level.size(), i + build_run_length);
+	idx_t levels_flat_offset = level_nr * zipped_level.size() + i;
+	for (auto j = i; j < next_limit; ++j) {
+		//	Initialise the next aggregate
+		auto curr_state = levels_flat_native.GetStatePtr(levels_flat_offset++);
+
+		//	Update this state (if it matches)
+		const auto prev_idx = std::get<0>(zipped_level[j]);
+		level[j] = prev_idx;
+		if (prev_idx < i + 1) {
+			updates[nupdate] = curr_state;
+			//	input_idx
+			sel[nupdate] = UnsafeNumericCast<sel_t>(std::get<1>(zipped_level[j]));
+			++nupdate;
 		}
 
-		tree.emplace_back(std::move(level), std::move(zipped_tree.tree[level_nr].second));
-
-		levels_flat_start.push_back(levels_flat_offset);
-		level_width *= FANOUT;
+		//	Merge the previous state (if any)
+		if (prev_state) {
+			sources[ncombine] = prev_state;
+			targets[ncombine] = curr_state;
+			++ncombine;
+		}
+		prev_state = curr_state;
+
+		//	Flush the states if one is maxed out.
+		if (MaxValue<idx_t>(ncombine, nupdate) >= STANDARD_VECTOR_SIZE) {
+			//	Push the updates first so they propagate
+			leaves.Reference(inputs);
+			leaves.Slice(sel, nupdate);
+			aggr.function.update(leaves.data.data(), aggr_input_data, leaves.ColumnCount(), update_v, nupdate);
+			nupdate = 0;
+
+			//	Combine the states sequentially
+			aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
+			ncombine = 0;
+		}
 	}
 
 	//	Flush any remaining states
@@ -1378,64 +1999,16 @@ WindowDistinctAggregator::DistinctSortTree::DistinctSortTree(ZippedElements &&pr
 		aggr.function.combine(source_v, target_v, aggr_input_data, ncombine);
 		ncombine = 0;
 	}
-}
-
-class WindowDistinctState : public WindowAggregatorState {
-public:
-	WindowDistinctState(const AggregateObject &aggr, const DataChunk &inputs, const WindowDistinctAggregator &tree);
-
-	void Evaluate(const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx);
-
-protected:
-	//! Flush the accumulated intermediate states into the result states
-	void FlushStates();
-
-	//! The aggregate function
-	const AggregateObject &aggr;
-	//! The aggregate function
-	const DataChunk &inputs;
-	//! The merge sort tree data
-	const WindowDistinctAggregator &tree;
-	//! The size of a single aggregate state
-	const idx_t state_size;
-	//! Data pointer that contains a vector of states, used for row aggregation
-	vector<data_t> state;
-	//! Reused result state container for the window functions
-	Vector statef;
-	//! A vector of pointers to "state", used for buffering intermediate aggregates
-	Vector statep;
-	//! Reused state pointers for combining tree elements
-	Vector statel;
-	//! Count of buffered values
-	idx_t flush_count;
-	//! The frame boundaries, used for the window functions
-	SubFrames frames;
-};
 
-WindowDistinctState::WindowDistinctState(const AggregateObject &aggr, const DataChunk &inputs,
-                                         const WindowDistinctAggregator &tree)
-    : aggr(aggr), inputs(inputs), tree(tree), state_size(aggr.function.state_size()),
-      state((state_size * STANDARD_VECTOR_SIZE)), statef(LogicalType::POINTER), statep(LogicalType::POINTER),
-      statel(LogicalType::POINTER), flush_count(0) {
-	InitSubFrames(frames, tree.exclude_mode);
-
-	//	Build the finalise vector that just points to the result states
-	data_ptr_t state_ptr = state.data();
-	D_ASSERT(statef.GetVectorType() == VectorType::FLAT_VECTOR);
-	statef.SetVectorType(VectorType::CONSTANT_VECTOR);
-	statef.Flatten(STANDARD_VECTOR_SIZE);
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
-		fdata[i] = state_ptr;
-		state_ptr += state_size;
-	}
+	++build_complete;
 }
 
-void WindowDistinctState::FlushStates() {
+void WindowDistinctAggregatorLocalState::FlushStates() {
 	if (!flush_count) {
 		return;
 	}
 
+	const auto &aggr = gastate.aggregator.aggr;
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
 	statel.Verify(flush_count);
 	aggr.function.combine(statel, statep, aggr_input_data, flush_count);
@@ -1443,17 +2016,20 @@ void WindowDistinctState::FlushStates() {
 	flush_count = 0;
 }
 
-void WindowDistinctState::Evaluate(const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) {
-	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
-	auto ldata = FlatVector::GetData<data_ptr_t>(statel);
+void WindowDistinctAggregatorLocalState::Evaluate(const WindowDistinctAggregatorGlobalState &gdstate,
+                                                  const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) {
+	auto ldata = FlatVector::GetData<const_data_ptr_t>(statel);
 	auto pdata = FlatVector::GetData<data_ptr_t>(statep);
 
-	const auto &merge_sort_tree = *tree.merge_sort_tree;
-	const auto running_aggs = tree.levels_flat_native.get();
+	const auto &merge_sort_tree = gdstate.merge_sort_tree;
+	const auto &levels_flat_native = gdstate.levels_flat_native;
+	const auto exclude_mode = gdstate.aggregator.exclude_mode;
 
-	EvaluateSubFrames(bounds, tree.exclude_mode, count, row_idx, frames, [&](idx_t rid) {
-		auto agg_state = fdata[rid];
-		aggr.function.initialize(agg_state);
+	//	Build the finalise vector that just points to the result states
+	statef.Initialize(count);
+
+	EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t rid) {
+		auto agg_state = statef.GetStatePtr(rid);
 
 		//	TODO: Extend AggregateLowerBound to handle subframes, just like SelectNth.
 		const auto lower = frames[0].start;
@@ -1463,8 +2039,8 @@ void WindowDistinctState::Evaluate(const DataChunk &bounds, Vector &result, idx_
 			                                    if (run_pos != run_begin) {
 				                                    //	Find the source aggregate
 				                                    // Buffer a merge of the indicated state into the current state
-				                                    const auto agg_idx = tree.levels_flat_start[level] + run_pos - 1;
-				                                    const auto running_agg = running_aggs + agg_idx * state_size;
+				                                    const auto agg_idx = gdstate.levels_flat_start[level] + run_pos - 1;
+				                                    const auto running_agg = levels_flat_native.GetStatePtr(agg_idx);
 				                                    pdata[flush_count] = agg_state;
 				                                    ldata[flush_count++] = running_agg;
 				                                    if (flush_count >= STANDARD_VECTOR_SIZE) {
@@ -1478,23 +2054,20 @@ void WindowDistinctState::Evaluate(const DataChunk &bounds, Vector &result, idx_
 	FlushStates();
 
 	//	Finalise the result aggregates and write to the result
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
-	aggr.function.finalize(statef, aggr_input_data, result, count, 0);
-
-	//	Destruct the result aggregates
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statef, aggr_input_data, count);
-	}
+	statef.Finalize(result);
+	statef.Destroy();
 }
 
-unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetLocalState() const {
-	return make_uniq<WindowDistinctState>(aggr, inputs, *this);
+unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
+	return make_uniq<WindowDistinctAggregatorLocalState>(gstate.Cast<const WindowDistinctAggregatorGlobalState>());
 }
 
-void WindowDistinctAggregator::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result,
-                                        idx_t count, idx_t row_idx) const {
-	auto &ldstate = lstate.Cast<WindowDistinctState>();
-	ldstate.Evaluate(bounds, result, count, row_idx);
+void WindowDistinctAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
+                                        const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
+
+	const auto &gdstate = gsink.Cast<WindowDistinctAggregatorGlobalState>();
+	auto &ldstate = lstate.Cast<WindowDistinctAggregatorLocalState>();
+	ldstate.Evaluate(gdstate, bounds, result, count, row_idx);
 }
 
 } // namespace duckdb