duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/execution/operator/aggregate/physical_window.hpp"
 
-#include "duckdb/common/sort/partition_state.hpp"
+#include "duckdb/common/sorting/hashed_sort.hpp"
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
+#include "duckdb/common/types/row/tuple_data_iterator.hpp"
 #include "duckdb/function/window/window_aggregate_function.hpp"
 #include "duckdb/function/window/window_executor.hpp"
 #include "duckdb/function/window/window_rank_function.hpp"
@@ -8,27 +10,26 @@
 #include "duckdb/function/window/window_shared_expressions.hpp"
 #include "duckdb/function/window/window_value_function.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
-//
-#include <numeric>
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
 //	Global sink state
 class WindowGlobalSinkState;
 
-enum WindowGroupStage : uint8_t { SINK, FINALIZE, GETDATA, DONE };
+enum WindowGroupStage : uint8_t { MASK, SINK, FINALIZE, GETDATA, DONE };
 
 struct WindowSourceTask {
-	WindowSourceTask(WindowGroupStage stage, idx_t group_idx, idx_t max_idx)
-	    : stage(stage), group_idx(group_idx), thread_idx(0), max_idx(max_idx) {
+	WindowSourceTask() {
 	}
-	WindowGroupStage stage;
+
+	WindowGroupStage stage = WindowGroupStage::DONE;
 	//! The hash group
-	idx_t group_idx;
+	idx_t group_idx = 0;
 	//! The thread index (for local state)
-	idx_t thread_idx;
+	idx_t thread_idx = 0;
 	//! The total block index count
-	idx_t max_idx;
+	idx_t max_idx = 0;
 	//! The first block index count
 	idx_t begin_idx = 0;
 	//! The end block index count
@@ -37,34 +38,38 @@ struct WindowSourceTask {
 
 class WindowHashGroup {
 public:
-	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-	using OrderMasks = PartitionGlobalHashGroup::OrderMasks;
-	using ExecutorGlobalStatePtr = unique_ptr<WindowExecutorGlobalState>;
+	using HashGroupPtr = unique_ptr<ColumnDataCollection>;
+	using OrderMasks = unordered_map<idx_t, ValidityMask>;
+	using ExecutorGlobalStatePtr = unique_ptr<GlobalSinkState>;
 	using ExecutorGlobalStates = vector<ExecutorGlobalStatePtr>;
-	using ExecutorLocalStatePtr = unique_ptr<WindowExecutorLocalState>;
+	using ExecutorLocalStatePtr = unique_ptr<LocalSinkState>;
 	using ExecutorLocalStates = vector<ExecutorLocalStatePtr>;
 	using ThreadLocalStates = vector<ExecutorLocalStates>;
 	using Task = WindowSourceTask;
 	using TaskPtr = optional_ptr<Task>;
+	using ScannerPtr = unique_ptr<WindowCollectionChunkScanner>;
 
-	WindowHashGroup(WindowGlobalSinkState &gstate, const idx_t hash_bin_p);
+	WindowHashGroup(WindowGlobalSinkState &gsink, HashGroupPtr &sorted, const idx_t hash_bin_p);
 
-	ExecutorGlobalStates &Initialize(WindowGlobalSinkState &gstate);
+	void AllocateMasks();
+	void ComputeMasks(const idx_t begin_idx, const idx_t end_idx);
 
-	// Scan all of the blocks during the build phase
-	unique_ptr<RowDataCollectionScanner> GetBuildScanner(idx_t block_idx) const {
-		if (!rows) {
-			return nullptr;
-		}
-		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, false);
-	}
+	ExecutorGlobalStates &GetGlobalStates(ClientContext &client);
 
-	// Scan a single block during the evaluate phase
-	unique_ptr<RowDataCollectionScanner> GetEvaluateScanner(idx_t block_idx) const {
-		//	Second pass can flush
-		D_ASSERT(rows);
-		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, true);
+	// The total number of tasks we will execute per thread
+	inline idx_t GetTaskCount() const {
+		return GetThreadCount() * (uint8_t(WindowGroupStage::DONE) - uint8_t(WindowGroupStage::MASK));
+	}
+	// The total number of threads we will use
+	inline idx_t GetThreadCount() const {
+		return group_threads;
 	}
+	// Set up the task parameters
+	idx_t InitTasks(idx_t per_thread);
+
+	// Scan all of the chunks, starting at a given point
+	ScannerPtr GetScanner(const idx_t begin_idx) const;
+	void UpdateScanner(ScannerPtr &scanner, idx_t begin_idx) const;
 
 	// The processing stage for this group
 	WindowGroupStage GetStage() const {
@@ -74,6 +79,12 @@ public:
 	bool TryPrepareNextStage() {
 		lock_guard<mutex> prepare_guard(lock);
 		switch (stage.load()) {
+		case WindowGroupStage::MASK:
+			if (masked == blocks) {
+				stage = WindowGroupStage::SINK;
+				return true;
+			}
+			return false;
 		case WindowGroupStage::SINK:
 			if (sunk == count) {
 				stage = WindowGroupStage::FINALIZE;
@@ -86,19 +97,29 @@ public:
 				return true;
 			}
 			return false;
-		default:
+		case WindowGroupStage::GETDATA:
+		case WindowGroupStage::DONE:
 			// never block in GETDATA
 			return true;
 		}
+
+		//	Stop Linux whinging about control flow...
+		return true;
 	}
 
-	bool TryNextTask(TaskPtr &task) {
-		if (next_task >= tasks.size()) {
+	bool TryNextTask(Task &task) {
+		if (next_task >= GetTaskCount()) {
 			return false;
 		}
-		task = tasks[next_task];
-		auto group_stage = GetStage();
-		if (task->stage == group_stage) {
+		const auto group_stage = GetStage();
+		const auto group_threads = GetThreadCount();
+		task.stage = WindowGroupStage(next_task / group_threads);
+		if (task.stage == group_stage) {
+			task.thread_idx = next_task % group_threads;
+			task.group_idx = hash_bin;
+			task.begin_idx = task.thread_idx * per_thread;
+			task.max_idx = rows->ChunkCount();
+			task.end_idx = MinValue<idx_t>(task.begin_idx + per_thread, task.max_idx);
 			++next_task;
 			return true;
 		}
@@ -106,23 +127,22 @@ public:
 		return false;
 	}
 
+	//! The shared global state from sinking
+	WindowGlobalSinkState &gsink;
 	//! The hash partition data
 	HashGroupPtr hash_group;
 	//! The size of the group
 	idx_t count = 0;
 	//! The number of blocks in the group
 	idx_t blocks = 0;
-	unique_ptr<RowDataCollection> rows;
-	unique_ptr<RowDataCollection> heap;
-	RowLayout layout;
+	unique_ptr<ColumnDataCollection> rows;
+	TupleDataLayout layout;
 	//! The partition boundary mask
 	ValidityMask partition_mask;
 	//! The order boundary mask
 	OrderMasks order_masks;
 	//! The fully materialised data collection
 	unique_ptr<WindowCollection> collection;
-	//! External paging
-	bool external;
 	// The processing stage for this group
 	atomic<WindowGroupStage> stage;
 	//! The function global states for this hash group
@@ -134,10 +154,14 @@ public:
 	idx_t hash_bin;
 	//! Single threading lock
 	mutex lock;
-	//! The list of tasks for this group
-	vector<Task> tasks;
+	//! The the number of blocks per thread.
+	idx_t per_thread = 0;
+	//! The the number of blocks per thread.
+	idx_t group_threads = 0;
 	//! The next task to process
 	idx_t next_task = 0;
+	//! Count of masked blocks
+	std::atomic<idx_t> masked;
 	//! Count of sunk rows
 	std::atomic<idx_t> sunk;
 	//! Count of finalized blocks
@@ -146,13 +170,8 @@ public:
 	std::atomic<idx_t> completed;
 	//! The output ordering batch index this hash group starts at
 	idx_t batch_base;
-
-private:
-	void MaterializeSortedData();
 };
 
-class WindowPartitionGlobalSinkState;
-
 class WindowGlobalSinkState : public GlobalSinkState {
 public:
 	using ExecutorPtr = unique_ptr<WindowExecutor>;
@@ -160,68 +179,45 @@ public:
 
 	WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context);
 
+	SinkFinalizeType Finalize(ClientContext &client, InterruptState &interrupt_state) {
+		OperatorSinkFinalizeInput finalize {*hashed_sink, interrupt_state};
+		auto result = global_partition->Finalize(client, finalize);
+
+		return result;
+	}
+
 	//! Parent operator
 	const PhysicalWindow &op;
-	//! Execution context
-	ClientContext &context;
+	//! Client context
+	ClientContext &client;
+	//! The partitioned sunk data
+	unique_ptr<HashedSort> global_partition;
 	//! The partitioned sunk data
-	unique_ptr<WindowPartitionGlobalSinkState> global_partition;
+	unique_ptr<GlobalSinkState> hashed_sink;
+	//! The number of sunk rows (for progress)
+	atomic<idx_t> count;
 	//! The execution functions
 	Executors executors;
 	//! The shared expressions library
 	WindowSharedExpressions shared;
 };
 
-class WindowPartitionGlobalSinkState : public PartitionGlobalSinkState {
-public:
-	using WindowHashGroupPtr = unique_ptr<WindowHashGroup>;
-
-	WindowPartitionGlobalSinkState(WindowGlobalSinkState &gsink, const BoundWindowExpression &wexpr)
-	    : PartitionGlobalSinkState(gsink.context, wexpr.partitions, wexpr.orders, gsink.op.children[0].get().GetTypes(),
-	                               wexpr.partitions_stats, gsink.op.estimated_cardinality),
-	      gsink(gsink) {
-	}
-	~WindowPartitionGlobalSinkState() override = default;
-
-	void OnBeginMerge() override {
-		PartitionGlobalSinkState::OnBeginMerge();
-		window_hash_groups.resize(hash_groups.size());
-	}
-
-	void OnSortedPartition(const idx_t group_idx) override {
-		PartitionGlobalSinkState::OnSortedPartition(group_idx);
-		window_hash_groups[group_idx] = make_uniq<WindowHashGroup>(gsink, group_idx);
-	}
-
-	//! Operator global sink state
-	WindowGlobalSinkState &gsink;
-	//! The sorted hash groups
-	vector<WindowHashGroupPtr> window_hash_groups;
-};
-
 //	Per-thread sink state
 class WindowLocalSinkState : public LocalSinkState {
 public:
-	WindowLocalSinkState(ClientContext &context, const WindowGlobalSinkState &gstate)
-	    : local_partition(context, *gstate.global_partition) {
+	WindowLocalSinkState(ExecutionContext &context, const WindowGlobalSinkState &gstate)
+	    : local_group(gstate.global_partition->GetLocalSinkState(context)) {
 	}
 
-	void Sink(DataChunk &input_chunk) {
-		local_partition.Sink(input_chunk);
-	}
-
-	void Combine() {
-		local_partition.Combine();
-	}
-
-	PartitionLocalSinkState local_partition;
+	unique_ptr<LocalSinkState> local_group;
 };
 
 // this implements a sorted window functions variant
-PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list_p,
-                               idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list_p)),
-      order_idx(0), is_order_dependent(false) {
+PhysicalWindow::PhysicalWindow(PhysicalPlan &physical_plan, vector<LogicalType> types,
+                               vector<unique_ptr<Expression>> select_list_p, idx_t estimated_cardinality,
+                               PhysicalOperatorType type)
+    : PhysicalOperator(physical_plan, type, std::move(types), estimated_cardinality),
+      select_list(std::move(select_list_p)), order_idx(0), is_order_dependent(false) {
 
 	idx_t max_orders = 0;
 	for (idx_t i = 0; i < select_list.size(); ++i) {
@@ -239,108 +235,109 @@ PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expr
 	}
 }
 
-static unique_ptr<WindowExecutor> WindowExecutorFactory(BoundWindowExpression &wexpr, ClientContext &context,
+static unique_ptr<WindowExecutor> WindowExecutorFactory(BoundWindowExpression &wexpr, ClientContext &client,
                                                         WindowSharedExpressions &shared, WindowAggregationMode mode) {
 	switch (wexpr.GetExpressionType()) {
 	case ExpressionType::WINDOW_AGGREGATE:
-		return make_uniq<WindowAggregateExecutor>(wexpr, context, shared, mode);
+		return make_uniq<WindowAggregateExecutor>(wexpr, client, shared, mode);
 	case ExpressionType::WINDOW_ROW_NUMBER:
-		return make_uniq<WindowRowNumberExecutor>(wexpr, context, shared);
+		return make_uniq<WindowRowNumberExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_RANK_DENSE:
-		return make_uniq<WindowDenseRankExecutor>(wexpr, context, shared);
+		return make_uniq<WindowDenseRankExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_RANK:
-		return make_uniq<WindowRankExecutor>(wexpr, context, shared);
+		return make_uniq<WindowRankExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_PERCENT_RANK:
-		return make_uniq<WindowPercentRankExecutor>(wexpr, context, shared);
+		return make_uniq<WindowPercentRankExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_CUME_DIST:
-		return make_uniq<WindowCumeDistExecutor>(wexpr, context, shared);
+		return make_uniq<WindowCumeDistExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_NTILE:
-		return make_uniq<WindowNtileExecutor>(wexpr, context, shared);
+		return make_uniq<WindowNtileExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
-		return make_uniq<WindowLeadLagExecutor>(wexpr, context, shared);
+		return make_uniq<WindowLeadLagExecutor>(wexpr, shared);
+	case ExpressionType::WINDOW_FILL:
+		return make_uniq<WindowFillExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_FIRST_VALUE:
-		return make_uniq<WindowFirstValueExecutor>(wexpr, context, shared);
+		return make_uniq<WindowFirstValueExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_LAST_VALUE:
-		return make_uniq<WindowLastValueExecutor>(wexpr, context, shared);
+		return make_uniq<WindowLastValueExecutor>(wexpr, shared);
 	case ExpressionType::WINDOW_NTH_VALUE:
-		return make_uniq<WindowNthValueExecutor>(wexpr, context, shared);
+		return make_uniq<WindowNthValueExecutor>(wexpr, shared);
 		break;
 	default:
 		throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType()));
 	}
 }
 
-WindowGlobalSinkState::WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context)
-    : op(op), context(context) {
+WindowGlobalSinkState::WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &client)
+    : op(op), client(client), count(0) {
 
 	D_ASSERT(op.select_list[op.order_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
 	auto &wexpr = op.select_list[op.order_idx]->Cast<BoundWindowExpression>();
 
-	const auto mode = DBConfig::GetConfig(context).options.window_mode;
+	const auto mode = DBConfig::GetSetting<DebugWindowModeSetting>(client);
 	for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
 		D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
 		auto &wexpr = op.select_list[expr_idx]->Cast<BoundWindowExpression>();
-		auto wexec = WindowExecutorFactory(wexpr, context, shared, mode);
+		auto wexec = WindowExecutorFactory(wexpr, client, shared, mode);
 		executors.emplace_back(std::move(wexec));
 	}
 
-	global_partition = make_uniq<WindowPartitionGlobalSinkState>(*this, wexpr);
+	global_partition = make_uniq<HashedSort>(client, wexpr.partitions, wexpr.orders, op.children[0].get().GetTypes(),
+	                                         wexpr.partitions_stats, op.estimated_cardinality);
+	hashed_sink = global_partition->GetGlobalSinkState(client);
 }
 
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
-SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
-
-	lstate.Sink(chunk);
+SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &sink) const {
+	auto &gstate = sink.global_state.Cast<WindowGlobalSinkState>();
+	auto &lstate = sink.local_state.Cast<WindowLocalSinkState>();
+	gstate.count += chunk.size();
 
-	return SinkResultType::NEED_MORE_INPUT;
+	OperatorSinkInput hsink {*gstate.hashed_sink, *lstate.local_group, sink.interrupt_state};
+	return gstate.global_partition->Sink(context, chunk, hsink);
 }
 
-SinkCombineResultType PhysicalWindow::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
-	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
-	lstate.Combine();
+SinkCombineResultType PhysicalWindow::Combine(ExecutionContext &context, OperatorSinkCombineInput &combine) const {
+	auto &gstate = combine.global_state.Cast<WindowGlobalSinkState>();
+	auto &lstate = combine.local_state.Cast<WindowLocalSinkState>();
 
-	return SinkCombineResultType::FINISHED;
+	OperatorSinkCombineInput hcombine {*gstate.hashed_sink, *lstate.local_group, combine.interrupt_state};
+	return gstate.global_partition->Combine(context, hcombine);
 }
 
 unique_ptr<LocalSinkState> PhysicalWindow::GetLocalSinkState(ExecutionContext &context) const {
 	auto &gstate = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowLocalSinkState>(context.client, gstate);
+	return make_uniq<WindowLocalSinkState>(context, gstate);
 }
 
-unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<WindowGlobalSinkState>(*this, context);
+unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &client) const {
+	return make_uniq<WindowGlobalSinkState>(*this, client);
 }
 
-SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
                                           OperatorSinkFinalizeInput &input) const {
-	auto &state = input.global_state.Cast<WindowGlobalSinkState>();
-
-	//	Did we get any data?
-	if (!state.global_partition->count) {
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
+	auto &gsink = input.global_state.Cast<WindowGlobalSinkState>();
+	auto &global_partition = *gsink.global_partition;
+	auto &hashed_sink = *gsink.hashed_sink;
 
-	// Do we have any sorting to schedule?
-	if (state.global_partition->rows) {
-		D_ASSERT(!state.global_partition->grouping_data);
-		return state.global_partition->rows->count ? SinkFinalizeType::READY : SinkFinalizeType::NO_OUTPUT_POSSIBLE;
-	}
+	OperatorSinkFinalizeInput hfinalize {hashed_sink, input.interrupt_state};
+	auto result = global_partition.Finalize(client, hfinalize);
 
-	// Find the first group to sort
-	if (!state.global_partition->HasMergeTasks()) {
-		// Empty input!
-		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
+	//	Did we get any data?
+	if (result != SinkFinalizeType::READY) {
+		return result;
 	}
 
-	// Schedule all the sorts for maximum thread utilisation
-	auto new_event = make_shared_ptr<PartitionMergeEvent>(*state.global_partition, pipeline, *this);
-	event.InsertEvent(std::move(new_event));
+	return global_partition.MaterializeHashGroups(pipeline, event, *this, hfinalize);
+}
 
-	return SinkFinalizeType::READY;
+ProgressData PhysicalWindow::GetSinkProgress(ClientContext &context, GlobalSinkState &gstate,
+                                             const ProgressData source_progress) const {
+	auto &gsink = gstate.Cast<WindowGlobalSinkState>();
+	return gsink.global_partition->GetSinkProgress(context, *gsink.hashed_sink, source_progress);
 }
 
 //===--------------------------------------------------------------------===//
@@ -348,16 +345,14 @@ SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 class WindowGlobalSourceState : public GlobalSourceState {
 public:
-	using ScannerPtr = unique_ptr<RowDataCollectionScanner>;
+	using WindowHashGroupPtr = unique_ptr<WindowHashGroup>;
+	using ScannerPtr = unique_ptr<TupleDataChunkIterator>;
 	using Task = WindowSourceTask;
 	using TaskPtr = optional_ptr<Task>;
 	using PartitionBlock = std::pair<idx_t, idx_t>;
 
 	WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p);
 
-	//! Build task list
-	void CreateTaskList();
-
 	//! Are there any more tasks?
 	bool HasMoreTasks() const {
 		return !stopped && started < total_tasks;
@@ -366,12 +361,14 @@ public:
 		return !stopped && finished < total_tasks;
 	}
 	//! Get the next task given the current state
-	bool TryNextTask(TaskPtr &task);
+	bool TryNextTask(TaskPtr &task, Task &task_local);
 
 	//! Context for executing computations
-	ClientContext &context;
+	ClientContext &client;
 	//! All the sunk data
 	WindowGlobalSinkState &gsink;
+	//! The sorted hash groups
+	vector<WindowHashGroupPtr> window_hash_groups;
 	//! The total number of blocks to process;
 	idx_t total_blocks = 0;
 	//! The sorted list of (blocks, group_idx) pairs
@@ -390,8 +387,8 @@ public:
 	atomic<idx_t> finished;
 	//! Stop producing tasks
 	atomic<bool> stopped;
-	//! The number of rows returned
-	atomic<idx_t> returned;
+	//! The number of tasks completed. This will combine both build and evaluate.
+	atomic<idx_t> completed;
 
 public:
 	idx_t MaxThreads() override {
@@ -399,55 +396,38 @@ public:
 	}
 
 protected:
+	//! Build task list
+	void CreateTaskList();
 	//! Finish a task
 	void FinishTask(TaskPtr task);
 };
 
-WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p)
-    : context(context_p), gsink(gsink_p), next_group(0), locals(0), started(0), finished(0), stopped(false),
-      returned(0) {
-	auto &gpart = gsink.global_partition;
-	auto &window_hash_groups = gsink.global_partition->window_hash_groups;
+WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &client, WindowGlobalSinkState &gsink_p)
+    : client(client), gsink(gsink_p), next_group(0), locals(0), started(0), finished(0), stopped(false), completed(0) {
 
-	if (window_hash_groups.empty()) {
-		//	OVER()
-		if (gpart->rows && !gpart->rows->blocks.empty()) {
-			// We need to construct the single WindowHashGroup here because the sort tasks will not be run.
-			window_hash_groups.emplace_back(make_uniq<WindowHashGroup>(gsink, idx_t(0)));
-			total_blocks = gpart->rows->blocks.size();
-		}
-	} else {
-		idx_t batch_base = 0;
-		for (auto &window_hash_group : window_hash_groups) {
-			if (!window_hash_group) {
-				continue;
-			}
-			auto &rows = window_hash_group->rows;
-			if (!rows) {
-				continue;
-			}
+	auto &global_partition = *gsink.global_partition;
+	auto hashed_source = global_partition.GetGlobalSourceState(client, *gsink.hashed_sink);
+	auto &hash_groups = global_partition.GetHashGroups(*hashed_source);
+	window_hash_groups.resize(hash_groups.size());
 
-			const auto block_count = window_hash_group->rows->blocks.size();
-			window_hash_group->batch_base = batch_base;
-			batch_base += block_count;
+	for (idx_t group_idx = 0; group_idx < hash_groups.size(); ++group_idx) {
+		auto rows = std::move(hash_groups[group_idx]);
+		if (!rows) {
+			continue;
 		}
-		total_blocks = batch_base;
-	}
-}
-
-void WindowGlobalSourceState::CreateTaskList() {
-	//	Check whether we have a task list outside the mutex.
-	if (started.load()) {
-		return;
-	}
 
-	auto guard = Lock();
+		auto window_hash_group = make_uniq<WindowHashGroup>(gsink, rows, group_idx);
+		const auto block_count = window_hash_group->rows->ChunkCount();
+		window_hash_group->batch_base = total_blocks;
+		total_blocks += block_count;
 
-	auto &window_hash_groups = gsink.global_partition->window_hash_groups;
-	if (!partition_blocks.empty()) {
-		return;
+		window_hash_groups[group_idx] = std::move(window_hash_group);
 	}
 
+	CreateTaskList();
+}
+
+void WindowGlobalSourceState::CreateTaskList() {
 	//    Sort the groups from largest to smallest
 	if (window_hash_groups.empty()) {
 		return;
@@ -455,100 +435,92 @@ void WindowGlobalSourceState::CreateTaskList() {
 
 	for (idx_t group_idx = 0; group_idx < window_hash_groups.size(); ++group_idx) {
 		auto &window_hash_group = window_hash_groups[group_idx];
-		partition_blocks.emplace_back(window_hash_group->rows->blocks.size(), group_idx);
+		if (!window_hash_group) {
+			continue;
+		}
+		partition_blocks.emplace_back(window_hash_group->rows->ChunkCount(), group_idx);
 	}
 	std::sort(partition_blocks.begin(), partition_blocks.end(), std::greater<PartitionBlock>());
 
 	//	Schedule the largest group on as many threads as possible
-	const auto threads = locals.load();
+	auto &ts = TaskScheduler::GetScheduler(client);
+	const auto threads = NumericCast<idx_t>(ts.NumberOfThreads());
+
 	const auto &max_block = partition_blocks.front();
-	const auto per_thread = (max_block.first + threads - 1) / threads;
+
+	// To compute masks in parallel, we need to have the row count of the number of chunks per thread
+	// be a multiple of the mask entry size.  Usually, this is not a problem because
+	// STANDARD_VECTOR_SIZE >> ValidityMask::BITS_PER_VALUE, but if STANDARD_VECTOR_SIZE is say 2,
+	// we need to align the chunk count to the mask width.
+	const auto aligned_scale = MaxValue<idx_t>(ValidityMask::BITS_PER_VALUE / STANDARD_VECTOR_SIZE, 1);
+	const auto aligned_count = (max_block.first + aligned_scale - 1) / aligned_scale;
+	const auto per_thread = aligned_scale * ((aligned_count + threads - 1) / threads);
 	if (!per_thread) {
 		throw InternalException("No blocks per thread! %ld threads, %ld groups, %ld blocks, %ld hash group", threads,
 		                        partition_blocks.size(), max_block.first, max_block.second);
 	}
 
-	//	TODO: Generate dynamically instead of building a big list?
-	vector<WindowGroupStage> stages {WindowGroupStage::SINK, WindowGroupStage::FINALIZE, WindowGroupStage::GETDATA};
 	for (const auto &b : partition_blocks) {
-		auto &window_hash_group = *window_hash_groups[b.second];
-		auto &tasks = window_hash_group.tasks;
-		for (const auto &stage : stages) {
-			idx_t thread_count = 0;
-			for (Task task(stage, b.second, b.first); task.begin_idx < task.max_idx; task.begin_idx += per_thread) {
-				task.end_idx = MinValue<idx_t>(task.begin_idx + per_thread, task.max_idx);
-				tasks.emplace_back(task);
-				thread_count = ++task.thread_idx;
-				++total_tasks;
-			}
-			window_hash_group.thread_states.resize(thread_count);
-		}
-	}
-}
-
-void WindowHashGroup::MaterializeSortedData() {
-	auto &global_sort_state = *hash_group->global_sort;
-	if (global_sort_state.sorted_blocks.empty()) {
-		return;
-	}
-
-	// scan the sorted row data
-	D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-	auto &sb = *global_sort_state.sorted_blocks[0];
-
-	// Free up some memory before allocating more
-	sb.radix_sorting_data.clear();
-	sb.blob_sorting_data = nullptr;
-
-	// Move the sorting row blocks into our RDCs
-	auto &buffer_manager = global_sort_state.buffer_manager;
-	auto &sd = *sb.payload_data;
-
-	// Data blocks are required
-	D_ASSERT(!sd.data_blocks.empty());
-	auto &block = sd.data_blocks[0];
-	rows = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-	rows->blocks = std::move(sd.data_blocks);
-	rows->count = std::accumulate(rows->blocks.begin(), rows->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-
-	// Heap blocks are optional, but we want both for iteration.
-	if (!sd.heap_blocks.empty()) {
-		auto &block = sd.heap_blocks[0];
-		heap = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-		heap->blocks = std::move(sd.heap_blocks);
-		hash_group.reset();
-	} else {
-		heap = make_uniq<RowDataCollection>(buffer_manager, buffer_manager.GetBlockSize(), 1U, true);
+		total_tasks += window_hash_groups[b.second]->InitTasks(per_thread);
 	}
-	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
 }
 
-WindowHashGroup::WindowHashGroup(WindowGlobalSinkState &gstate, const idx_t hash_bin_p)
-    : count(0), blocks(0), stage(WindowGroupStage::SINK), hash_bin(hash_bin_p), sunk(0), finalized(0), completed(0),
-      batch_base(0) {
+WindowHashGroup::WindowHashGroup(WindowGlobalSinkState &gsink, HashGroupPtr &sorted, const idx_t hash_bin_p)
+    : gsink(gsink), count(0), blocks(0), rows(std::move(sorted)), stage(WindowGroupStage::MASK), hash_bin(hash_bin_p),
+      masked(0), sunk(0), finalized(0), completed(0), batch_base(0) {
 	// There are three types of partitions:
 	// 1. No partition (no sorting)
 	// 2. One partition (sorting, but no hashing)
 	// 3. Multiple partitions (sorting and hashing)
 
 	//	How big is the partition?
-	auto &gpart = *gstate.global_partition;
-	layout.Initialize(gpart.payload_types);
-	if (hash_bin < gpart.hash_groups.size() && gpart.hash_groups[hash_bin]) {
-		count = gpart.hash_groups[hash_bin]->count;
-	} else if (gpart.rows && !hash_bin) {
-		count = gpart.count;
+	auto &gpart = *gsink.global_partition;
+	layout.Initialize(gpart.payload_types, TupleDataValidityType::CAN_HAVE_NULL_VALUES);
+
+	if (rows) {
+		count = rows->Count();
+		blocks = rows->ChunkCount();
+	}
+
+	// Set up the collection for any fully materialised data
+	const auto &shared = WindowSharedExpressions::GetSortedExpressions(gsink.shared.coll_shared);
+	vector<LogicalType> types;
+	for (auto &expr : shared) {
+		types.emplace_back(expr->return_type);
+	}
+	auto &buffer_manager = BufferManager::GetBufferManager(gsink.client);
+	collection = make_uniq<WindowCollection>(buffer_manager, count, types);
+}
+
+unique_ptr<WindowCollectionChunkScanner> WindowHashGroup::GetScanner(const idx_t begin_idx) const {
+	if (!rows) {
+		return nullptr;
+	}
+
+	auto &scan_ids = gsink.global_partition->scan_ids;
+	return make_uniq<WindowCollectionChunkScanner>(*rows, scan_ids, begin_idx);
+}
+
+void WindowHashGroup::UpdateScanner(ScannerPtr &scanner, idx_t begin_idx) const {
+	if (!scanner || &scanner->collection != rows.get()) {
+		scanner.reset();
+		scanner = GetScanner(begin_idx);
 	} else {
+		scanner->Seek(begin_idx);
+	}
+}
+
+void WindowHashGroup::AllocateMasks() {
+	//	Single-threaded building as this is mostly memory allocation
+	lock_guard<mutex> gestate_guard(lock);
+	if (partition_mask.IsMaskSet()) {
 		return;
 	}
 
-	//	Initialise masks to false
+	//	Allocate masks inside the lock
 	partition_mask.Initialize(count);
-	partition_mask.SetAllInvalid(count);
 
-	const auto &executors = gstate.executors;
+	const auto &executors = gsink.executors;
 	for (auto &wexec : executors) {
 		auto &wexpr = wexec->wexpr;
 		auto &order_mask = order_masks[wexpr.partitions.size() + wexpr.orders.size()];
@@ -556,43 +528,102 @@ WindowHashGroup::WindowHashGroup(WindowGlobalSinkState &gstate, const idx_t hash
 			continue;
 		}
 		order_mask.Initialize(count);
-		order_mask.SetAllInvalid(count);
 	}
+}
+
+void WindowHashGroup::ComputeMasks(const idx_t block_begin, const idx_t block_end) {
+	D_ASSERT(count > 0);
+
+	//	Initialise our range
+	AllocateMasks();
+	const auto begin_entry = partition_mask.EntryCount(block_begin * STANDARD_VECTOR_SIZE);
+	const auto end_entry = partition_mask.EntryCount(MinValue<idx_t>(block_end * STANDARD_VECTOR_SIZE, count));
 
-	// Scan the sorted data into new Collections
-	external = gpart.external;
-	if (gpart.rows && !hash_bin) {
-		// Simple mask
+	//	If the data is unsorted, then the chunk sizes may be < STANDARD_VECTOR_SIZE,
+	//	and the entry range may be empty.
+	if (begin_entry >= end_entry) {
+		D_ASSERT(gsink.global_partition->sort_col_count == 0);
+		return;
+	}
+
+	partition_mask.SetRangeInvalid(count, begin_entry, end_entry);
+	if (!block_begin) {
 		partition_mask.SetValidUnsafe(0);
-		for (auto &order_mask : order_masks) {
+	}
+	for (auto &order_mask : order_masks) {
+		order_mask.second.SetRangeInvalid(count, begin_entry, end_entry);
+		if (!block_begin) {
 			order_mask.second.SetValidUnsafe(0);
 		}
-		//	No partition - align the heap blocks with the row blocks
-		rows = gpart.rows->CloneEmpty(gpart.rows->keep_pinned);
-		heap = gpart.strings->CloneEmpty(gpart.strings->keep_pinned);
-		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gpart.rows, *gpart.strings, layout);
-		external = true;
-	} else if (hash_bin < gpart.hash_groups.size()) {
-		// Overwrite the collections with the sorted data
-		D_ASSERT(gpart.hash_groups[hash_bin].get());
-		hash_group = std::move(gpart.hash_groups[hash_bin]);
-		hash_group->ComputeMasks(partition_mask, order_masks);
-		external = hash_group->global_sort->external;
-		MaterializeSortedData();
 	}
 
-	if (rows) {
-		blocks = rows->blocks.size();
+	//	If we are not sorting, then only the partition boundaries are needed.
+	if (!gsink.global_partition->sort) {
+		return;
 	}
 
-	// Set up the collection for any fully materialised data
-	const auto &shared = WindowSharedExpressions::GetSortedExpressions(gstate.shared.coll_shared);
-	vector<LogicalType> types;
-	for (auto &expr : shared) {
-		types.emplace_back(expr->return_type);
-	}
-	auto &buffer_manager = BufferManager::GetBufferManager(gstate.context);
-	collection = make_uniq<WindowCollection>(buffer_manager, count, types);
+	//	Set up the partition compare structs
+	auto &partitions = gsink.global_partition->partitions;
+	const auto key_count = partitions.size();
+
+	//	Set up the order data structures
+	auto &collection = *rows;
+	auto &scan_cols = gsink.global_partition->sort_ids;
+	WindowCollectionChunkScanner scanner(collection, scan_cols, block_begin);
+	unordered_map<idx_t, DataChunk> prefixes;
+	for (auto &order_mask : order_masks) {
+		D_ASSERT(order_mask.first >= partitions.size());
+		auto order_type = scanner.PrefixStructType(order_mask.first, partitions.size());
+		vector<LogicalType> types(2, order_type);
+		auto &keys = prefixes[order_mask.first];
+		// We can't use InitializeEmpty here because it doesn't set up all of the STRUCT internals...
+		keys.Initialize(collection.GetAllocator(), types);
+	}
+
+	WindowDeltaScanner(collection, block_begin, block_end, scan_cols, key_count,
+	                   [&](const idx_t row_idx, DataChunk &prev, DataChunk &curr, const idx_t ndistinct,
+	                       SelectionVector &distinct, const SelectionVector &matching) {
+		                   //	Process the partition boundaries
+		                   for (idx_t i = 0; i < ndistinct; ++i) {
+			                   const idx_t curr_index = row_idx + distinct.get_index(i);
+			                   partition_mask.SetValidUnsafe(curr_index);
+			                   for (auto &order_mask : order_masks) {
+				                   order_mask.second.SetValidUnsafe(curr_index);
+			                   }
+		                   }
+
+		                   //	Process the peers with each partition
+		                   const auto count = MinValue<idx_t>(prev.size(), curr.size());
+		                   const auto nmatch = count - ndistinct;
+		                   if (!nmatch) {
+			                   return;
+		                   }
+
+		                   for (auto &order_mask : order_masks) {
+			                   // If there are no order columns, then all the partition elements are peers and we are
+			                   // done
+			                   if (partitions.size() == order_mask.first) {
+				                   continue;
+			                   }
+			                   auto &prefix = prefixes[order_mask.first];
+			                   prefix.Reset();
+			                   auto &order_prev = prefix.data[0];
+			                   auto &order_curr = prefix.data[1];
+			                   scanner.ReferenceStructColumns(prev, order_prev, order_mask.first, partitions.size());
+			                   scanner.ReferenceStructColumns(curr, order_curr, order_mask.first, partitions.size());
+			                   if (ndistinct) {
+				                   prefix.Slice(matching, nmatch);
+			                   } else {
+				                   prefix.SetCardinality(nmatch);
+			                   }
+			                   const auto m = VectorOperations::DistinctFrom(order_curr, order_prev, nullptr, nmatch,
+			                                                                 &distinct, nullptr);
+			                   for (idx_t i = 0; i < m; ++i) {
+				                   const idx_t curr_index = row_idx + matching.get_index(distinct.get_index(i));
+				                   order_mask.second.SetValidUnsafe(curr_index);
+			                   }
+		                   }
+	                   });
 }
 
 // Per-thread scan state
@@ -615,7 +646,7 @@ public:
 	//! Assign the next task
 	bool TryAssignTask();
 	//! Execute a step in the current task
-	void ExecuteTask(DataChunk &chunk);
+	void ExecuteTask(ExecutionContext &context, DataChunk &chunk, InterruptState &interrupt);
 
 	//! The shared source state
 	WindowGlobalSourceState &gsource;
@@ -623,19 +654,24 @@ public:
 	idx_t batch_index;
 	//! The task this thread is working on
 	TaskPtr task;
+	//! The task storage
+	Task task_local;
 	//! The current source being processed
 	optional_ptr<WindowHashGroup> window_hash_group;
 	//! The scan cursor
-	unique_ptr<RowDataCollectionScanner> scanner;
-	//! Buffer for the inputs
-	DataChunk input_chunk;
+	unique_ptr<WindowCollectionChunkScanner> scanner;
 	//! Buffer for window results
 	DataChunk output_chunk;
 
 protected:
-	void Sink();
-	void Finalize();
-	void GetData(DataChunk &chunk);
+	//! Compute a mask range
+	void Mask(ExecutionContext &context, InterruptState &interrupt);
+	//! Sink tuples into function global states
+	void Sink(ExecutionContext &context, InterruptState &interrupt);
+	//! Post process function global state construction
+	void Finalize(ExecutionContext &context, InterruptState &interrupt);
+	//! Get a chunk by evaluating functions
+	void GetData(ExecutionContext &context, DataChunk &chunk, InterruptState &interrupt);
 
 	//! Storage and evaluation for the fully materialised data
 	unique_ptr<WindowBuilder> builder;
@@ -651,7 +687,26 @@ protected:
 	DataChunk eval_chunk;
 };
 
-WindowHashGroup::ExecutorGlobalStates &WindowHashGroup::Initialize(WindowGlobalSinkState &gsink) {
+idx_t WindowHashGroup::InitTasks(idx_t per_thread_p) {
+	per_thread = per_thread_p;
+	group_threads = (rows->ChunkCount() + per_thread - 1) / per_thread;
+	thread_states.resize(GetThreadCount());
+
+	return GetTaskCount();
+}
+
+void WindowLocalSourceState::Mask(ExecutionContext &context, InterruptState &interrupt) {
+	D_ASSERT(task);
+	D_ASSERT(task->stage == WindowGroupStage::MASK);
+
+	window_hash_group->ComputeMasks(task->begin_idx, task->end_idx);
+
+	//	Mark this range as done
+	window_hash_group->masked += (task->end_idx - task->begin_idx);
+	task->begin_idx = task->end_idx;
+}
+
+WindowHashGroup::ExecutorGlobalStates &WindowHashGroup::GetGlobalStates(ClientContext &client) {
 	//	Single-threaded building as this is mostly memory allocation
 	lock_guard<mutex> gestate_guard(lock);
 	const auto &executors = gsink.executors;
@@ -663,13 +718,13 @@ WindowHashGroup::ExecutorGlobalStates &WindowHashGroup::Initialize(WindowGlobalS
 	for (auto &wexec : executors) {
 		auto &wexpr = wexec->wexpr;
 		auto &order_mask = order_masks[wexpr.partitions.size() + wexpr.orders.size()];
-		gestates.emplace_back(wexec->GetGlobalState(count, partition_mask, order_mask));
+		gestates.emplace_back(wexec->GetGlobalState(client, count, partition_mask, order_mask));
 	}
 
 	return gestates;
 }
 
-void WindowLocalSourceState::Sink() {
+void WindowLocalSourceState::Sink(ExecutionContext &context, InterruptState &interrupt) {
 	D_ASSERT(task);
 	D_ASSERT(task->stage == WindowGroupStage::SINK);
 
@@ -678,67 +733,61 @@ void WindowLocalSourceState::Sink() {
 
 	// Create the global state for each function
 	// These can be large so we defer building them until we are ready.
-	auto &gestates = window_hash_group->Initialize(gsink);
+	auto &gestates = window_hash_group->GetGlobalStates(context.client);
 
 	//	Set up the local states
 	auto &local_states = window_hash_group->thread_states.at(task->thread_idx);
 	if (local_states.empty()) {
 		for (idx_t w = 0; w < executors.size(); ++w) {
-			local_states.emplace_back(executors[w]->GetLocalState(*gestates[w]));
+			local_states.emplace_back(executors[w]->GetLocalState(context, *gestates[w]));
 		}
 	}
 
 	//	First pass over the input without flushing
+	scanner = window_hash_group->GetScanner(task->begin_idx);
+	if (!scanner) {
+		return;
+	}
 	for (; task->begin_idx < task->end_idx; ++task->begin_idx) {
-		scanner = window_hash_group->GetBuildScanner(task->begin_idx);
-		if (!scanner) {
+		const idx_t input_idx = scanner->Scanned();
+		if (!scanner->Scan()) {
 			break;
 		}
-		while (true) {
-			//	TODO: Try to align on validity mask boundaries by starting ragged?
-			idx_t input_idx = scanner->Scanned();
-			input_chunk.Reset();
-			scanner->Scan(input_chunk);
-			if (input_chunk.size() == 0) {
-				break;
-			}
+		auto &input_chunk = scanner->chunk;
 
-			//	Compute fully materialised expressions
-			if (coll_chunk.data.empty()) {
-				coll_chunk.SetCardinality(input_chunk);
-			} else {
-				coll_chunk.Reset();
-				coll_exec.Execute(input_chunk, coll_chunk);
-				auto collection = window_hash_group->collection.get();
-				if (!builder || &builder->collection != collection) {
-					builder = make_uniq<WindowBuilder>(*collection);
-				}
-
-				builder->Sink(coll_chunk, input_idx);
+		//	Compute fully materialised expressions
+		if (coll_chunk.data.empty()) {
+			coll_chunk.SetCardinality(input_chunk);
+		} else {
+			coll_chunk.Reset();
+			coll_exec.Execute(input_chunk, coll_chunk);
+			auto collection = window_hash_group->collection.get();
+			if (!builder || &builder->collection != collection) {
+				builder = make_uniq<WindowBuilder>(*collection);
 			}
 
-			// Compute sink expressions
-			if (sink_chunk.data.empty()) {
-				sink_chunk.SetCardinality(input_chunk);
-			} else {
-				sink_chunk.Reset();
-				sink_exec.Execute(input_chunk, sink_chunk);
-			}
+			builder->Sink(coll_chunk, input_idx);
+		}
 
-			for (idx_t w = 0; w < executors.size(); ++w) {
-				executors[w]->Sink(sink_chunk, coll_chunk, input_idx, *gestates[w], *local_states[w]);
-			}
+		// Compute sink expressions
+		if (sink_chunk.data.empty()) {
+			sink_chunk.SetCardinality(input_chunk);
+		} else {
+			sink_chunk.Reset();
+			sink_exec.Execute(input_chunk, sink_chunk);
+		}
 
-			window_hash_group->sunk += input_chunk.size();
+		for (idx_t w = 0; w < executors.size(); ++w) {
+			OperatorSinkInput sink {*gestates[w], *local_states[w], interrupt};
+			executors[w]->Sink(context, sink_chunk, coll_chunk, input_idx, sink);
 		}
 
-		// External scanning assumes all blocks are swizzled.
-		scanner->SwizzleBlock(task->begin_idx);
-		scanner.reset();
+		window_hash_group->sunk += input_chunk.size();
 	}
+	scanner.reset();
 }
 
-void WindowLocalSourceState::Finalize() {
+void WindowLocalSourceState::Finalize(ExecutionContext &context, InterruptState &interrupt) {
 	D_ASSERT(task);
 	D_ASSERT(task->stage == WindowGroupStage::FINALIZE);
 
@@ -755,7 +804,8 @@ void WindowLocalSourceState::Finalize() {
 	auto &gestates = window_hash_group->gestates;
 	auto &local_states = window_hash_group->thread_states.at(task->thread_idx);
 	for (idx_t w = 0; w < executors.size(); ++w) {
-		executors[w]->Finalize(*gestates[w], *local_states[w], window_hash_group->collection);
+		OperatorSinkInput sink {*gestates[w], *local_states[w], interrupt};
+		executors[w]->Finalize(context, window_hash_group->collection, sink);
 	}
 
 	//	Mark this range as done
@@ -764,19 +814,16 @@ void WindowLocalSourceState::Finalize() {
 }
 
 WindowLocalSourceState::WindowLocalSourceState(WindowGlobalSourceState &gsource)
-    : gsource(gsource), batch_index(0), coll_exec(gsource.context), sink_exec(gsource.context),
-      eval_exec(gsource.context) {
+    : gsource(gsource), batch_index(0), coll_exec(gsource.client), sink_exec(gsource.client),
+      eval_exec(gsource.client) {
 	auto &gsink = gsource.gsink;
-	auto &global_partition = *gsink.global_partition;
-
-	input_chunk.Initialize(global_partition.allocator, global_partition.payload_types);
 
 	vector<LogicalType> output_types;
 	for (auto &wexec : gsink.executors) {
 		auto &wexpr = wexec->wexpr;
 		output_types.emplace_back(wexpr.return_type);
 	}
-	output_chunk.Initialize(global_partition.allocator, output_types);
+	output_chunk.Initialize(gsource.client, output_types);
 
 	auto &shared = gsink.shared;
 	shared.PrepareCollection(coll_exec, coll_chunk);
@@ -786,7 +833,7 @@ WindowLocalSourceState::WindowLocalSourceState(WindowGlobalSourceState &gsource)
 	++gsource.locals;
 }
 
-bool WindowGlobalSourceState::TryNextTask(TaskPtr &task) {
+bool WindowGlobalSourceState::TryNextTask(TaskPtr &task, Task &task_local) {
 	auto guard = Lock();
 	FinishTask(task);
 
@@ -796,13 +843,13 @@ bool WindowGlobalSourceState::TryNextTask(TaskPtr &task) {
 	}
 
 	//	Run through the active groups looking for one that can assign a task
-	auto &gpart = *gsink.global_partition;
 	for (const auto &group_idx : active_groups) {
-		auto &window_hash_group = gpart.window_hash_groups[group_idx];
+		auto &window_hash_group = window_hash_groups[group_idx];
 		if (window_hash_group->TryPrepareNextStage()) {
 			UnblockTasks(guard);
 		}
-		if (window_hash_group->TryNextTask(task)) {
+		if (window_hash_group->TryNextTask(task_local)) {
+			task = task_local;
 			++started;
 			return true;
 		}
@@ -813,15 +860,16 @@ bool WindowGlobalSourceState::TryNextTask(TaskPtr &task) {
 		const auto group_idx = partition_blocks[next_group++].second;
 		active_groups.emplace_back(group_idx);
 
-		auto &window_hash_group = gpart.window_hash_groups[group_idx];
+		auto &window_hash_group = window_hash_groups[group_idx];
 		if (window_hash_group->TryPrepareNextStage()) {
 			UnblockTasks(guard);
 		}
-		if (!window_hash_group->TryNextTask(task)) {
+		if (!window_hash_group->TryNextTask(task_local)) {
 			//	Group has no tasks (empty?)
 			continue;
 		}
 
+		task = task_local;
 		++started;
 		return true;
 	}
@@ -836,17 +884,19 @@ void WindowGlobalSourceState::FinishTask(TaskPtr task) {
 		return;
 	}
 
-	auto &gpart = *gsink.global_partition;
 	const auto group_idx = task->group_idx;
-	auto &finished_hash_group = gpart.window_hash_groups[group_idx];
+	auto &finished_hash_group = window_hash_groups[group_idx];
 	D_ASSERT(finished_hash_group);
 
-	if (++finished_hash_group->completed >= finished_hash_group->tasks.size()) {
+	if (++finished_hash_group->completed >= finished_hash_group->GetTaskCount()) {
 		finished_hash_group.reset();
 		//	Remove it from the active groups
 		auto &v = active_groups;
 		v.erase(std::remove(v.begin(), v.end(), group_idx), v.end());
 	}
+
+	//	Count the global tasks completed.
+	++completed;
 }
 
 bool WindowLocalSourceState::TryAssignTask() {
@@ -862,30 +912,32 @@ bool WindowLocalSourceState::TryAssignTask() {
 	// Scanner first, as it may be referencing sort blocks in the hash group
 	scanner.reset();
 
-	return gsource.TryNextTask(task);
+	return gsource.TryNextTask(task, task_local);
 }
 
-void WindowLocalSourceState::ExecuteTask(DataChunk &result) {
-	auto &gsink = gsource.gsink;
-
+void WindowLocalSourceState::ExecuteTask(ExecutionContext &context, DataChunk &result, InterruptState &interrupt) {
 	// Update the hash group
-	window_hash_group = gsink.global_partition->window_hash_groups[task->group_idx].get();
+	window_hash_group = gsource.window_hash_groups[task->group_idx].get();
 
 	// Process the new state
 	switch (task->stage) {
+	case WindowGroupStage::MASK:
+		Mask(context, interrupt);
+		D_ASSERT(TaskFinished());
+		break;
 	case WindowGroupStage::SINK:
-		Sink();
+		Sink(context, interrupt);
 		D_ASSERT(TaskFinished());
 		break;
 	case WindowGroupStage::FINALIZE:
-		Finalize();
+		Finalize(context, interrupt);
 		D_ASSERT(TaskFinished());
 		break;
 	case WindowGroupStage::GETDATA:
 		D_ASSERT(!TaskFinished());
-		GetData(result);
+		GetData(context, result, interrupt);
 		break;
-	default:
+	case WindowGroupStage::DONE:
 		throw InternalException("Invalid window source state.");
 	}
 
@@ -895,17 +947,15 @@ void WindowLocalSourceState::ExecuteTask(DataChunk &result) {
 	}
 }
 
-void WindowLocalSourceState::GetData(DataChunk &result) {
+void WindowLocalSourceState::GetData(ExecutionContext &context, DataChunk &result, InterruptState &interrupt) {
 	D_ASSERT(window_hash_group->GetStage() == WindowGroupStage::GETDATA);
 
-	if (!scanner || !scanner->Remaining()) {
-		scanner = window_hash_group->GetEvaluateScanner(task->begin_idx);
-		batch_index = window_hash_group->batch_base + task->begin_idx;
-	}
+	window_hash_group->UpdateScanner(scanner, task->begin_idx);
+	batch_index = window_hash_group->batch_base + task->begin_idx;
 
 	const auto position = scanner->Scanned();
-	input_chunk.Reset();
-	scanner->Scan(input_chunk);
+	auto &input_chunk = scanner->chunk;
+	scanner->Scan();
 
 	const auto &executors = gsource.gsink.executors;
 	auto &gestates = window_hash_group->gestates;
@@ -913,8 +963,6 @@ void WindowLocalSourceState::GetData(DataChunk &result) {
 	output_chunk.Reset();
 	for (idx_t expr_idx = 0; expr_idx < executors.size(); ++expr_idx) {
 		auto &executor = *executors[expr_idx];
-		auto &gstate = *gestates[expr_idx];
-		auto &lstate = *local_states[expr_idx];
 		auto &result = output_chunk.data[expr_idx];
 		if (eval_chunk.data.empty()) {
 			eval_chunk.SetCardinality(input_chunk);
@@ -922,7 +970,8 @@ void WindowLocalSourceState::GetData(DataChunk &result) {
 			eval_chunk.Reset();
 			eval_exec.Execute(input_chunk, eval_chunk);
 		}
-		executor.Evaluate(position, eval_chunk, result, lstate, gstate);
+		OperatorSinkInput sink {*gestates[expr_idx], *local_states[expr_idx], interrupt};
+		executor.Evaluate(context, position, eval_chunk, result, sink);
 	}
 	output_chunk.SetCardinality(input_chunk);
 	output_chunk.Verify();
@@ -936,10 +985,8 @@ void WindowLocalSourceState::GetData(DataChunk &result) {
 		result.data[out_idx++].Reference(output_chunk.data[col_idx]);
 	}
 
-	// If we done with this block, move to the next one
-	if (!scanner->Remaining()) {
-		++task->begin_idx;
-	}
+	// Move to the next chunk
+	++task->begin_idx;
 
 	result.Verify();
 }
@@ -950,9 +997,9 @@ unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContex
 	return make_uniq<WindowLocalSourceState>(gsource);
 }
 
-unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &context) const {
+unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &client) const {
 	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowGlobalSourceState>(context, gsink);
+	return make_uniq<WindowGlobalSourceState>(client, gsink);
 }
 
 bool PhysicalWindow::SupportsPartitioning(const OperatorPartitionInfo &partition_info) const {
@@ -980,19 +1027,22 @@ OrderPreservationType PhysicalWindow::SourceOrder() const {
 	return OrderPreservationType::FIXED_ORDER;
 }
 
-ProgressData PhysicalWindow::GetProgress(ClientContext &context, GlobalSourceState &gsource_p) const {
+ProgressData PhysicalWindow::GetProgress(ClientContext &client, GlobalSourceState &gsource_p) const {
 	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
-	const auto returned = gsource.returned.load();
-
 	auto &gsink = gsource.gsink;
-	const auto count = gsink.global_partition->count.load();
+	const auto count = gsink.count.load();
+	const auto completed = gsource.completed.load();
+
 	ProgressData res;
 	if (count) {
-		res.done = double(returned);
-		res.total = double(count);
+		res.done = double(completed);
+		res.total = double(gsource.total_tasks);
+		//	Convert to tuples.
+		res.Normalize(double(count));
 	} else {
 		res.SetInvalid();
 	}
+
 	return res;
 }
 
@@ -1007,16 +1057,14 @@ OperatorPartitionData PhysicalWindow::GetPartitionData(ExecutionContext &context
 }
 
 SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
-	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
-
-	gsource.CreateTaskList();
+                                         OperatorSourceInput &source) const {
+	auto &gsource = source.global_state.Cast<WindowGlobalSourceState>();
+	auto &lsource = source.local_state.Cast<WindowLocalSourceState>();
 
 	while (gsource.HasUnfinishedTasks() && chunk.size() == 0) {
 		if (!lsource.TaskFinished() || lsource.TryAssignTask()) {
 			try {
-				lsource.ExecuteTask(chunk);
+				lsource.ExecuteTask(context, chunk, source.interrupt_state);
 			} catch (...) {
 				gsource.stopped = true;
 				throw;
@@ -1030,13 +1078,11 @@ SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &c
 			} else {
 				// there are more tasks available, but we can't execute them yet
 				// block the source
-				return gsource.BlockSource(guard, input.interrupt_state);
+				return gsource.BlockSource(guard, source.interrupt_state);
 			}
 		}
 	}
 
-	gsource.returned += chunk.size();
-
 	if (chunk.size() == 0) {
 		return SourceResultType::FINISHED;
 	}