duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

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

@@ -14,7 +14,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/partitionable_hashtable.hpp"
+#include "duckdb/execution/window_executor.hpp"
 #include "duckdb/execution/window_segment_tree.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/config.hpp"
@@ -32,7 +32,7 @@ namespace duckdb {
 class WindowGlobalSinkState : public GlobalSinkState {
 public:
 	WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context)
-	    : mode(DBConfig::GetConfig(context).options.window_mode) {
+	    : op(op), mode(DBConfig::GetConfig(context).options.window_mode) {
 
 		D_ASSERT(op.select_list[0]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
 		auto &wexpr = op.select_list[0]->Cast<BoundWindowExpression>();
@@ -42,6 +42,7 @@ public:
 		                                        wexpr.partitions_stats, op.estimated_cardinality);
 	}
 
+	const PhysicalWindow &op;
 	unique_ptr<PartitionGlobalSinkState> global_partition;
 	WindowAggregationMode mode;
 };
@@ -78,977 +79,40 @@ PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expr
 	}
 }
 
-static idx_t FindNextStart(const ValidityMask &mask, idx_t l, const idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = MinValue(l + n - 1, r);
-		n -= MinValue(n, r - l);
-		return start;
-	}
-
-	while (l < r) {
-		//	If l is aligned with the start of a block, and the block is blank, then skip forward one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(l, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && !shift) {
-			l += ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop over the block
-		for (; shift < ValidityMask::BITS_PER_VALUE && l < r; ++shift, ++l) {
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MinValue(l, r);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the end of the range
-	return r;
-}
-
-static idx_t FindPrevStart(const ValidityMask &mask, const idx_t l, idx_t r, idx_t &n) {
-	if (mask.AllValid()) {
-		auto start = (r <= l + n) ? l : r - n;
-		n -= r - start;
-		return start;
-	}
-
-	while (l < r) {
-		// If r is aligned with the start of a block, and the previous block is blank,
-		// then skip backwards one block.
-		idx_t entry_idx;
-		idx_t shift;
-		mask.GetEntryIndex(r - 1, entry_idx, shift);
-
-		const auto block = mask.GetValidityEntry(entry_idx);
-		if (mask.NoneValid(block) && (shift + 1 == ValidityMask::BITS_PER_VALUE)) {
-			// r is nonzero (> l) and word aligned, so this will not underflow.
-			r -= ValidityMask::BITS_PER_VALUE;
-			continue;
-		}
-
-		// Loop backwards over the block
-		// shift is probing r-1 >= l >= 0
-		for (++shift; shift-- > 0; --r) {
-			if (mask.RowIsValid(block, shift) && --n == 0) {
-				return MaxValue(l, r - 1);
-			}
-		}
-	}
-
-	//	Didn't find a start so return the start of the range
-	return l;
-}
-
-static void PrepareInputExpressions(vector<unique_ptr<Expression>> &exprs, ExpressionExecutor &executor,
-                                    DataChunk &chunk) {
-	if (exprs.empty()) {
-		return;
-	}
-
-	vector<LogicalType> types;
-	for (idx_t expr_idx = 0; expr_idx < exprs.size(); ++expr_idx) {
-		types.push_back(exprs[expr_idx]->return_type);
-		executor.AddExpression(*exprs[expr_idx]);
-	}
-
-	if (!types.empty()) {
-		auto &allocator = executor.GetAllocator();
-		chunk.Initialize(allocator, types);
-	}
-}
-
-static void PrepareInputExpression(Expression &expr, ExpressionExecutor &executor, DataChunk &chunk) {
-	vector<LogicalType> types;
-	types.push_back(expr.return_type);
-	executor.AddExpression(expr);
-
-	auto &allocator = executor.GetAllocator();
-	chunk.Initialize(allocator, types);
-}
-
-struct WindowInputExpression {
-	WindowInputExpression(optional_ptr<Expression> expr_p, ClientContext &context)
-	    : expr(expr_p), ptype(PhysicalType::INVALID), scalar(true), executor(context) {
-		if (expr) {
-			PrepareInputExpression(*expr, executor, chunk);
-			ptype = expr->return_type.InternalType();
-			scalar = expr->IsScalar();
-		}
-	}
-
-	void Execute(DataChunk &input_chunk) {
-		if (expr) {
-			chunk.Reset();
-			executor.Execute(input_chunk, chunk);
-			chunk.Verify();
-		}
-	}
-
-	template <typename T>
-	inline T GetCell(idx_t i) const {
-		D_ASSERT(!chunk.data.empty());
-		const auto data = FlatVector::GetData<T>(chunk.data[0]);
-		return data[scalar ? 0 : i];
-	}
-
-	inline bool CellIsNull(idx_t i) const {
-		D_ASSERT(!chunk.data.empty());
-		if (chunk.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			return ConstantVector::IsNull(chunk.data[0]);
-		}
-		return FlatVector::IsNull(chunk.data[0], i);
-	}
-
-	inline void CopyCell(Vector &target, idx_t target_offset) const {
-		D_ASSERT(!chunk.data.empty());
-		auto &source = chunk.data[0];
-		auto source_offset = scalar ? 0 : target_offset;
-		VectorOperations::Copy(source, target, source_offset + 1, source_offset, target_offset);
-	}
-
-	optional_ptr<Expression> expr;
-	PhysicalType ptype;
-	bool scalar;
-	ExpressionExecutor executor;
-	DataChunk chunk;
-};
-
-struct WindowInputColumn {
-	WindowInputColumn(Expression *expr_p, ClientContext &context, idx_t capacity_p)
-	    : input_expr(expr_p, context), count(0), capacity(capacity_p) {
-		if (input_expr.expr) {
-			target = make_uniq<Vector>(input_expr.chunk.data[0].GetType(), capacity);
-		}
-	}
-
-	void Append(DataChunk &input_chunk) {
-		if (input_expr.expr) {
-			const auto source_count = input_chunk.size();
-			D_ASSERT(count + source_count <= capacity);
-			if (!input_expr.scalar || !count) {
-				input_expr.Execute(input_chunk);
-				auto &source = input_expr.chunk.data[0];
-				VectorOperations::Copy(source, *target, source_count, 0, count);
-			}
-			count += source_count;
-		}
-	}
-
-	inline bool CellIsNull(idx_t i) {
-		D_ASSERT(target);
-		D_ASSERT(i < count);
-		return FlatVector::IsNull(*target, input_expr.scalar ? 0 : i);
-	}
-
-	template <typename T>
-	inline T GetCell(idx_t i) const {
-		D_ASSERT(target);
-		D_ASSERT(i < count);
-		const auto data = FlatVector::GetData<T>(*target);
-		return data[input_expr.scalar ? 0 : i];
-	}
-
-	WindowInputExpression input_expr;
-
-private:
-	unique_ptr<Vector> target;
-	idx_t count;
-	idx_t capacity;
-};
-
-static inline bool BoundaryNeedsPeer(const WindowBoundary &boundary) {
-	switch (boundary) {
-	case WindowBoundary::CURRENT_ROW_RANGE:
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		return true;
-	default:
-		return false;
-	}
-}
-
-struct WindowBoundariesState {
-	static inline bool IsScalar(const unique_ptr<Expression> &expr) {
-		return expr ? expr->IsScalar() : true;
-	}
-
-	WindowBoundariesState(BoundWindowExpression &wexpr, const idx_t input_size)
-	    : type(wexpr.type), input_size(input_size), start_boundary(wexpr.start), end_boundary(wexpr.end),
-	      partition_count(wexpr.partitions.size()), order_count(wexpr.orders.size()),
-	      range_sense(wexpr.orders.empty() ? OrderType::INVALID : wexpr.orders[0].type),
-	      has_preceding_range(wexpr.start == WindowBoundary::EXPR_PRECEDING_RANGE ||
-	                          wexpr.end == WindowBoundary::EXPR_PRECEDING_RANGE),
-	      has_following_range(wexpr.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	                          wexpr.end == WindowBoundary::EXPR_FOLLOWING_RANGE),
-	      needs_peer(BoundaryNeedsPeer(wexpr.end) || wexpr.type == ExpressionType::WINDOW_CUME_DIST) {
-	}
-
-	void Update(const idx_t row_idx, WindowInputColumn &range_collection, const idx_t source_offset,
-	            WindowInputExpression &boundary_start, WindowInputExpression &boundary_end,
-	            const ValidityMask &partition_mask, const ValidityMask &order_mask);
-
-	// Cached lookups
-	const ExpressionType type;
-	const idx_t input_size;
-	const WindowBoundary start_boundary;
-	const WindowBoundary end_boundary;
-	const size_t partition_count;
-	const size_t order_count;
-	const OrderType range_sense;
-	const bool has_preceding_range;
-	const bool has_following_range;
-	const bool needs_peer;
-
-	idx_t partition_start = 0;
-	idx_t partition_end = 0;
-	idx_t peer_start = 0;
-	idx_t peer_end = 0;
-	idx_t valid_start = 0;
-	idx_t valid_end = 0;
-	int64_t window_start = -1;
-	int64_t window_end = -1;
-	bool is_same_partition = false;
-	bool is_peer = false;
-};
-
-static bool WindowNeedsRank(const BoundWindowExpression &wexpr) {
-	return wexpr.type == ExpressionType::WINDOW_PERCENT_RANK || wexpr.type == ExpressionType::WINDOW_RANK ||
-	       wexpr.type == ExpressionType::WINDOW_RANK_DENSE || wexpr.type == ExpressionType::WINDOW_CUME_DIST;
-}
-
-template <typename T>
-static T GetCell(DataChunk &chunk, idx_t column, idx_t index) {
-	D_ASSERT(chunk.ColumnCount() > column);
-	auto &source = chunk.data[column];
-	const auto data = FlatVector::GetData<T>(source);
-	return data[index];
-}
-
-static bool CellIsNull(DataChunk &chunk, idx_t column, idx_t index) {
-	D_ASSERT(chunk.ColumnCount() > column);
-	auto &source = chunk.data[column];
-	return FlatVector::IsNull(source, index);
-}
-
-static void CopyCell(DataChunk &chunk, idx_t column, idx_t index, Vector &target, idx_t target_offset) {
-	D_ASSERT(chunk.ColumnCount() > column);
-	auto &source = chunk.data[column];
-	VectorOperations::Copy(source, target, index + 1, index, target_offset);
-}
-
-template <typename T>
-struct WindowColumnIterator {
-	using iterator = WindowColumnIterator<T>;
-	using iterator_category = std::forward_iterator_tag;
-	using difference_type = std::ptrdiff_t;
-	using value_type = T;
-	using reference = T;
-	using pointer = idx_t;
-
-	explicit WindowColumnIterator(WindowInputColumn &coll_p, pointer pos_p = 0) : coll(&coll_p), pos(pos_p) {
-	}
-
-	inline reference operator*() const {
-		return coll->GetCell<T>(pos);
-	}
-	inline explicit operator pointer() const {
-		return pos;
-	}
-
-	inline iterator &operator++() {
-		++pos;
-		return *this;
-	}
-	inline iterator operator++(int) {
-		auto result = *this;
-		++(*this);
-		return result;
-	}
-
-	friend inline bool operator==(const iterator &a, const iterator &b) {
-		return a.pos == b.pos;
-	}
-	friend inline bool operator!=(const iterator &a, const iterator &b) {
-		return a.pos != b.pos;
-	}
-
-private:
-	optional_ptr<WindowInputColumn> coll;
-	pointer pos;
-};
-
-template <typename T, typename OP>
-struct OperationCompare : public std::function<bool(T, T)> {
-	inline bool operator()(const T &lhs, const T &val) const {
-		return OP::template Operation(lhs, val);
-	}
-};
-
-template <typename T, typename OP, bool FROM>
-static idx_t FindTypedRangeBound(WindowInputColumn &over, const idx_t order_begin, const idx_t order_end,
-                                 WindowInputExpression &boundary, const idx_t boundary_row) {
-	D_ASSERT(!boundary.CellIsNull(boundary_row));
-	const auto val = boundary.GetCell<T>(boundary_row);
-
-	OperationCompare<T, OP> comp;
-	WindowColumnIterator<T> begin(over, order_begin);
-	WindowColumnIterator<T> end(over, order_end);
-	if (FROM) {
-		return idx_t(std::lower_bound(begin, end, val, comp));
-	} else {
-		return idx_t(std::upper_bound(begin, end, val, comp));
-	}
-}
-
-template <typename OP, bool FROM>
-static idx_t FindRangeBound(WindowInputColumn &over, const idx_t order_begin, const idx_t order_end,
-                            WindowInputExpression &boundary, const idx_t expr_idx) {
-	D_ASSERT(boundary.chunk.ColumnCount() == 1);
-	D_ASSERT(boundary.chunk.data[0].GetType().InternalType() == over.input_expr.ptype);
-
-	switch (over.input_expr.ptype) {
-	case PhysicalType::INT8:
-		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT16:
-		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT32:
-		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT64:
-		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT8:
-		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT16:
-		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT32:
-		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::UINT64:
-		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INT128:
-		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::FLOAT:
-		return FindTypedRangeBound<float, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::DOUBLE:
-		return FindTypedRangeBound<double, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case PhysicalType::INTERVAL:
-		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	default:
-		throw InternalException("Unsupported column type for RANGE");
-	}
-}
-
-template <bool FROM>
-static idx_t FindOrderedRangeBound(WindowInputColumn &over, const OrderType range_sense, const idx_t order_begin,
-                                   const idx_t order_end, WindowInputExpression &boundary, const idx_t expr_idx) {
-	switch (range_sense) {
-	case OrderType::ASCENDING:
-		return FindRangeBound<LessThan, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	case OrderType::DESCENDING:
-		return FindRangeBound<GreaterThan, FROM>(over, order_begin, order_end, boundary, expr_idx);
-	default:
-		throw InternalException("Unsupported ORDER BY sense for RANGE");
-	}
-}
-
-void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range_collection, const idx_t expr_idx,
-                                   WindowInputExpression &boundary_start, WindowInputExpression &boundary_end,
-                                   const ValidityMask &partition_mask, const ValidityMask &order_mask) {
-
-	auto &bounds = *this;
-	if (bounds.partition_count + bounds.order_count > 0) {
-
-		// determine partition and peer group boundaries to ultimately figure out window size
-		bounds.is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
-		bounds.is_peer = !order_mask.RowIsValidUnsafe(row_idx);
-
-		// when the partition changes, recompute the boundaries
-		if (!bounds.is_same_partition) {
-			bounds.partition_start = row_idx;
-			bounds.peer_start = row_idx;
-
-			// find end of partition
-			bounds.partition_end = bounds.input_size;
-			if (bounds.partition_count) {
-				idx_t n = 1;
-				bounds.partition_end = FindNextStart(partition_mask, bounds.partition_start + 1, bounds.input_size, n);
-			}
-
-			// Find valid ordering values for the new partition
-			// so we can exclude NULLs from RANGE expression computations
-			bounds.valid_start = bounds.partition_start;
-			bounds.valid_end = bounds.partition_end;
-
-			if ((bounds.valid_start < bounds.valid_end) && bounds.has_preceding_range) {
-				// Exclude any leading NULLs
-				if (range_collection.CellIsNull(bounds.valid_start)) {
-					idx_t n = 1;
-					bounds.valid_start = FindNextStart(order_mask, bounds.valid_start + 1, bounds.valid_end, n);
-				}
-			}
-
-			if ((bounds.valid_start < bounds.valid_end) && bounds.has_following_range) {
-				// Exclude any trailing NULLs
-				if (range_collection.CellIsNull(bounds.valid_end - 1)) {
-					idx_t n = 1;
-					bounds.valid_end = FindPrevStart(order_mask, bounds.valid_start, bounds.valid_end, n);
-				}
-			}
-
-		} else if (!bounds.is_peer) {
-			bounds.peer_start = row_idx;
-		}
-
-		if (bounds.needs_peer) {
-			bounds.peer_end = bounds.partition_end;
-			if (bounds.order_count) {
-				idx_t n = 1;
-				bounds.peer_end = FindNextStart(order_mask, bounds.peer_start + 1, bounds.partition_end, n);
-			}
-		}
-
-	} else {
-		bounds.is_same_partition = false;
-		bounds.is_peer = true;
-		bounds.partition_end = bounds.input_size;
-		bounds.peer_end = bounds.partition_end;
-	}
-
-	// determine window boundaries depending on the type of expression
-	bounds.window_start = -1;
-	bounds.window_end = -1;
-
-	switch (bounds.start_boundary) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		bounds.window_start = bounds.partition_start;
-		break;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		bounds.window_start = row_idx;
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.window_start = bounds.peer_start;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS: {
-		if (!TrySubtractOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
-		                                    bounds.window_start)) {
-			throw OutOfRangeException("Overflow computing ROWS PRECEDING start");
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_ROWS: {
-		if (!TryAddOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(expr_idx),
-		                               bounds.window_start)) {
-			throw OutOfRangeException("Overflow computing ROWS FOLLOWING start");
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_PRECEDING_RANGE: {
-		if (boundary_start.CellIsNull(expr_idx)) {
-			bounds.window_start = bounds.peer_start;
-		} else {
-			bounds.window_start = FindOrderedRangeBound<true>(range_collection, bounds.range_sense, bounds.valid_start,
-			                                                  row_idx, boundary_start, expr_idx);
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
-		if (boundary_start.CellIsNull(expr_idx)) {
-			bounds.window_start = bounds.peer_start;
-		} else {
-			bounds.window_start = FindOrderedRangeBound<true>(range_collection, bounds.range_sense, row_idx,
-			                                                  bounds.valid_end, boundary_start, expr_idx);
-		}
+static unique_ptr<WindowExecutor> WindowExecutorFactory(BoundWindowExpression &wexpr, ClientContext &context,
+                                                        const ValidityMask &partition_mask,
+                                                        const ValidityMask &order_mask, const idx_t payload_count,
+                                                        WindowAggregationMode mode) {
+	switch (wexpr.type) {
+	case ExpressionType::WINDOW_AGGREGATE:
+		return make_uniq<WindowAggregateExecutor>(wexpr, context, payload_count, partition_mask, order_mask, mode);
+	case ExpressionType::WINDOW_ROW_NUMBER:
+		return make_uniq<WindowRowNumberExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_RANK_DENSE:
+		return make_uniq<WindowDenseRankExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_RANK:
+		return make_uniq<WindowRankExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_PERCENT_RANK:
+		return make_uniq<WindowPercentRankExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_CUME_DIST:
+		return make_uniq<WindowCumeDistExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_NTILE:
+		return make_uniq<WindowNtileExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_LEAD:
+	case ExpressionType::WINDOW_LAG:
+		return make_uniq<WindowLeadLagExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_FIRST_VALUE:
+		return make_uniq<WindowFirstValueExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_LAST_VALUE:
+		return make_uniq<WindowLastValueExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
+	case ExpressionType::WINDOW_NTH_VALUE:
+		return make_uniq<WindowNthValueExecutor>(wexpr, context, payload_count, partition_mask, order_mask);
 		break;
-	}
 	default:
-		throw InternalException("Unsupported window start boundary");
-	}
-
-	switch (bounds.end_boundary) {
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		bounds.window_end = row_idx + 1;
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		bounds.window_end = bounds.peer_end;
-		break;
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		bounds.window_end = bounds.partition_end;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		if (!TrySubtractOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
-		                                    bounds.window_end)) {
-			throw OutOfRangeException("Overflow computing ROWS PRECEDING end");
-		}
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		if (!TryAddOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(expr_idx),
-		                               bounds.window_end)) {
-			throw OutOfRangeException("Overflow computing ROWS FOLLOWING end");
-		}
-		break;
-	case WindowBoundary::EXPR_PRECEDING_RANGE: {
-		if (boundary_end.CellIsNull(expr_idx)) {
-			bounds.window_end = bounds.peer_end;
-		} else {
-			bounds.window_end = FindOrderedRangeBound<false>(range_collection, bounds.range_sense, bounds.valid_start,
-			                                                 row_idx, boundary_end, expr_idx);
-		}
-		break;
-	}
-	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
-		if (boundary_end.CellIsNull(expr_idx)) {
-			bounds.window_end = bounds.peer_end;
-		} else {
-			bounds.window_end = FindOrderedRangeBound<false>(range_collection, bounds.range_sense, row_idx,
-			                                                 bounds.valid_end, boundary_end, expr_idx);
-		}
-		break;
-	}
-	default:
-		throw InternalException("Unsupported window end boundary");
-	}
-
-	// clamp windows to partitions if they should exceed
-	if (bounds.window_start < (int64_t)bounds.partition_start) {
-		bounds.window_start = bounds.partition_start;
-	}
-	if (bounds.window_start > (int64_t)bounds.partition_end) {
-		bounds.window_start = bounds.partition_end;
-	}
-	if (bounds.window_end < (int64_t)bounds.partition_start) {
-		bounds.window_end = bounds.partition_start;
-	}
-	if (bounds.window_end > (int64_t)bounds.partition_end) {
-		bounds.window_end = bounds.partition_end;
-	}
-
-	if (bounds.window_start < 0 || bounds.window_end < 0) {
-		throw InternalException("Failed to compute window boundaries");
+		throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.type));
 	}
 }
 
-struct WindowExecutor {
-	static bool IsConstantAggregate(const BoundWindowExpression &wexpr);
-
-	WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, const ValidityMask &partition_mask,
-	               const idx_t count);
-
-	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count);
-	void Finalize(WindowAggregationMode mode);
-
-	void Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &result, const ValidityMask &partition_mask,
-	              const ValidityMask &order_mask);
-
-	// The function
-	BoundWindowExpression &wexpr;
-
-	// Frame management
-	WindowBoundariesState bounds;
-	uint64_t dense_rank = 1;
-	uint64_t rank_equal = 0;
-	uint64_t rank = 1;
-
-	// Expression collections
-	DataChunk payload_collection;
-	ExpressionExecutor payload_executor;
-	DataChunk payload_chunk;
-
-	ExpressionExecutor filter_executor;
-	ValidityMask filter_mask;
-	vector<validity_t> filter_bits;
-	SelectionVector filter_sel;
-
-	// LEAD/LAG Evaluation
-	WindowInputExpression leadlag_offset;
-	WindowInputExpression leadlag_default;
-
-	// evaluate boundaries if present. Parser has checked boundary types.
-	WindowInputExpression boundary_start;
-	WindowInputExpression boundary_end;
-
-	// evaluate RANGE expressions, if needed
-	WindowInputColumn range;
-
-	// IGNORE NULLS
-	ValidityMask ignore_nulls;
-
-	// build a segment tree for frame-adhering aggregates
-	// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
-	unique_ptr<WindowSegmentTree> segment_tree = nullptr;
-
-	// all aggregate values are the same for each partition
-	unique_ptr<WindowConstantAggregate> constant_aggregate = nullptr;
-};
-
-bool WindowExecutor::IsConstantAggregate(const BoundWindowExpression &wexpr) {
-	if (!wexpr.aggregate) {
-		return false;
-	}
-
-	//	COUNT(*) is already handled efficiently by segment trees.
-	if (wexpr.children.empty()) {
-		return false;
-	}
-
-	/*
-	    The default framing option is RANGE UNBOUNDED PRECEDING, which
-	    is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT
-	    ROW; it sets the frame to be all rows from the partition start
-	    up through the current row's last peer (a row that the window's
-	    ORDER BY clause considers equivalent to the current row; all
-	    rows are peers if there is no ORDER BY). In general, UNBOUNDED
-	    PRECEDING means that the frame starts with the first row of the
-	    partition, and similarly UNBOUNDED FOLLOWING means that the
-	    frame ends with the last row of the partition, regardless of
-	    RANGE, ROWS or GROUPS mode. In ROWS mode, CURRENT ROW means that
-	    the frame starts or ends with the current row; but in RANGE or
-	    GROUPS mode it means that the frame starts or ends with the
-	    current row's first or last peer in the ORDER BY ordering. The
-	    offset PRECEDING and offset FOLLOWING options vary in meaning
-	    depending on the frame mode.
-	*/
-	switch (wexpr.start) {
-	case WindowBoundary::UNBOUNDED_PRECEDING:
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		if (!wexpr.orders.empty()) {
-			return false;
-		}
-		break;
-	default:
-		return false;
-	}
-
-	switch (wexpr.end) {
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		break;
-	case WindowBoundary::CURRENT_ROW_RANGE:
-		if (!wexpr.orders.empty()) {
-			return false;
-		}
-		break;
-	default:
-		return false;
-	}
-
-	return true;
-}
-
-WindowExecutor::WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, const ValidityMask &partition_mask,
-                               const idx_t count)
-    : wexpr(wexpr), bounds(wexpr, count), payload_collection(), payload_executor(context), filter_executor(context),
-      leadlag_offset(wexpr.offset_expr.get(), context), leadlag_default(wexpr.default_expr.get(), context),
-      boundary_start(wexpr.start_expr.get(), context), boundary_end(wexpr.end_expr.get(), context),
-      range((bounds.has_preceding_range || bounds.has_following_range) ? wexpr.orders[0].expression.get() : nullptr,
-            context, count)
-
-{
-	// TODO we could evaluate those expressions in parallel
-
-	//	Check for constant aggregate
-	if (IsConstantAggregate(wexpr)) {
-		constant_aggregate =
-		    make_uniq<WindowConstantAggregate>(AggregateObject(wexpr), wexpr.return_type, partition_mask, count);
-	}
-
-	// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
-	if (wexpr.filter_expr) {
-		// 	Start with all invalid and set the ones that pass
-		filter_bits.resize(ValidityMask::ValidityMaskSize(count), 0);
-		filter_mask.Initialize(filter_bits.data());
-		filter_executor.AddExpression(*wexpr.filter_expr);
-		filter_sel.Initialize(STANDARD_VECTOR_SIZE);
-	}
-
-	// TODO: child may be a scalar, don't need to materialize the whole collection then
-
-	// evaluate inner expressions of window functions, could be more complex
-	PrepareInputExpressions(wexpr.children, payload_executor, payload_chunk);
-
-	auto types = payload_chunk.GetTypes();
-	if (!types.empty()) {
-		payload_collection.Initialize(Allocator::Get(context), types);
-	}
-}
-
-void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) {
-	// Single pass over the input to produce the global data.
-	// Vectorisation for the win...
-
-	// Set up a validity mask for IGNORE NULLS
-	bool check_nulls = false;
-	if (wexpr.ignore_nulls) {
-		switch (wexpr.type) {
-		case ExpressionType::WINDOW_LEAD:
-		case ExpressionType::WINDOW_LAG:
-		case ExpressionType::WINDOW_FIRST_VALUE:
-		case ExpressionType::WINDOW_LAST_VALUE:
-		case ExpressionType::WINDOW_NTH_VALUE:
-			check_nulls = true;
-			break;
-		default:
-			break;
-		}
-	}
-
-	const auto count = input_chunk.size();
-
-	idx_t filtered = 0;
-	SelectionVector *filtering = nullptr;
-	if (wexpr.filter_expr) {
-		filtering = &filter_sel;
-		filtered = filter_executor.SelectExpression(input_chunk, filter_sel);
-		for (idx_t f = 0; f < filtered; ++f) {
-			filter_mask.SetValid(input_idx + filter_sel[f]);
-		}
-	}
-
-	if (!wexpr.children.empty()) {
-		payload_chunk.Reset();
-		payload_executor.Execute(input_chunk, payload_chunk);
-		payload_chunk.Verify();
-		if (constant_aggregate) {
-			constant_aggregate->Sink(payload_chunk, filtering, filtered);
-		} else {
-			payload_collection.Append(payload_chunk, true);
-		}
-
-		// process payload chunks while they are still piping hot
-		if (check_nulls) {
-			UnifiedVectorFormat vdata;
-			payload_chunk.data[0].ToUnifiedFormat(count, vdata);
-			if (!vdata.validity.AllValid()) {
-				//	Lazily materialise the contents when we find the first NULL
-				if (ignore_nulls.AllValid()) {
-					ignore_nulls.Initialize(total_count);
-				}
-				// Write to the current position
-				if (input_idx % ValidityMask::BITS_PER_VALUE == 0) {
-					// If we are at the edge of an output entry, just copy the entries
-					auto dst = ignore_nulls.GetData() + ignore_nulls.EntryCount(input_idx);
-					auto src = vdata.validity.GetData();
-					for (auto entry_count = vdata.validity.EntryCount(count); entry_count-- > 0;) {
-						*dst++ = *src++;
-					}
-				} else {
-					// If not, we have ragged data and need to copy one bit at a time.
-					for (idx_t i = 0; i < count; ++i) {
-						ignore_nulls.Set(input_idx + i, vdata.validity.RowIsValid(i));
-					}
-				}
-			}
-		}
-	}
-
-	range.Append(input_chunk);
-}
-
-void WindowExecutor::Finalize(WindowAggregationMode mode) {
-	// build a segment tree for frame-adhering aggregates
-	// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
-	if (constant_aggregate) {
-		constant_aggregate->Finalize();
-	} else if (wexpr.aggregate) {
-		segment_tree = make_uniq<WindowSegmentTree>(AggregateObject(wexpr), wexpr.return_type, &payload_collection,
-		                                            filter_mask, mode);
-	}
-}
-
-void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &result, const ValidityMask &partition_mask,
-                              const ValidityMask &order_mask) {
-	// Evaluate the row-level arguments
-	boundary_start.Execute(input_chunk);
-	boundary_end.Execute(input_chunk);
-
-	leadlag_offset.Execute(input_chunk);
-	leadlag_default.Execute(input_chunk);
-
-	// this is the main loop, go through all sorted rows and compute window function result
-	for (idx_t output_offset = 0; output_offset < input_chunk.size(); ++output_offset, ++row_idx) {
-		// special case, OVER (), aggregate over everything
-		bounds.Update(row_idx, range, output_offset, boundary_start, boundary_end, partition_mask, order_mask);
-		if (WindowNeedsRank(wexpr)) {
-			if (!bounds.is_same_partition || row_idx == 0) { // special case for first row, need to init
-				dense_rank = 1;
-				rank = 1;
-				rank_equal = 0;
-			} else if (!bounds.is_peer) {
-				dense_rank++;
-				rank += rank_equal;
-				rank_equal = 0;
-			}
-			rank_equal++;
-		}
-
-		// if no values are read for window, result is NULL
-		if (bounds.window_start >= bounds.window_end) {
-			FlatVector::SetNull(result, output_offset, true);
-			continue;
-		}
-
-		switch (wexpr.type) {
-		case ExpressionType::WINDOW_AGGREGATE: {
-			if (constant_aggregate) {
-				constant_aggregate->Compute(result, output_offset, bounds.window_start, bounds.window_end);
-			} else {
-				segment_tree->Compute(result, output_offset, bounds.window_start, bounds.window_end);
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_ROW_NUMBER: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = row_idx - bounds.partition_start + 1;
-			break;
-		}
-		case ExpressionType::WINDOW_RANK_DENSE: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = dense_rank;
-			break;
-		}
-		case ExpressionType::WINDOW_RANK: {
-			auto rdata = FlatVector::GetData<int64_t>(result);
-			rdata[output_offset] = rank;
-			break;
-		}
-		case ExpressionType::WINDOW_PERCENT_RANK: {
-			int64_t denom = (int64_t)bounds.partition_end - bounds.partition_start - 1;
-			double percent_rank = denom > 0 ? ((double)rank - 1) / denom : 0;
-			auto rdata = FlatVector::GetData<double>(result);
-			rdata[output_offset] = percent_rank;
-			break;
-		}
-		case ExpressionType::WINDOW_CUME_DIST: {
-			int64_t denom = (int64_t)bounds.partition_end - bounds.partition_start;
-			double cume_dist = denom > 0 ? ((double)(bounds.peer_end - bounds.partition_start)) / denom : 0;
-			auto rdata = FlatVector::GetData<double>(result);
-			rdata[output_offset] = cume_dist;
-			break;
-		}
-		case ExpressionType::WINDOW_NTILE: {
-			D_ASSERT(payload_collection.ColumnCount() == 1);
-			if (CellIsNull(payload_collection, 0, row_idx)) {
-				FlatVector::SetNull(result, output_offset, true);
-			} else {
-				auto n_param = GetCell<int64_t>(payload_collection, 0, row_idx);
-				if (n_param < 1) {
-					throw InvalidInputException("Argument for ntile must be greater than zero");
-				}
-				// With thanks from SQLite's ntileValueFunc()
-				int64_t n_total = bounds.partition_end - bounds.partition_start;
-				if (n_param > n_total) {
-					// more groups allowed than we have values
-					// map every entry to a unique group
-					n_param = n_total;
-				}
-				int64_t n_size = (n_total / n_param);
-				// find the row idx within the group
-				D_ASSERT(row_idx >= bounds.partition_start);
-				int64_t adjusted_row_idx = row_idx - bounds.partition_start;
-				// now compute the ntile
-				int64_t n_large = n_total - n_param * n_size;
-				int64_t i_small = n_large * (n_size + 1);
-				int64_t result_ntile;
-
-				D_ASSERT((n_large * (n_size + 1) + (n_param - n_large) * n_size) == n_total);
-
-				if (adjusted_row_idx < i_small) {
-					result_ntile = 1 + adjusted_row_idx / (n_size + 1);
-				} else {
-					result_ntile = 1 + n_large + (adjusted_row_idx - i_small) / n_size;
-				}
-				// result has to be between [1, NTILE]
-				D_ASSERT(result_ntile >= 1 && result_ntile <= n_param);
-				auto rdata = FlatVector::GetData<int64_t>(result);
-				rdata[output_offset] = result_ntile;
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_LEAD:
-		case ExpressionType::WINDOW_LAG: {
-			int64_t offset = 1;
-			if (wexpr.offset_expr) {
-				offset = leadlag_offset.GetCell<int64_t>(output_offset);
-			}
-			int64_t val_idx = (int64_t)row_idx;
-			if (wexpr.type == ExpressionType::WINDOW_LEAD) {
-				val_idx += offset;
-			} else {
-				val_idx -= offset;
-			}
-
-			idx_t delta = 0;
-			if (val_idx < (int64_t)row_idx) {
-				// Count backwards
-				delta = idx_t(row_idx - val_idx);
-				val_idx = FindPrevStart(ignore_nulls, bounds.partition_start, row_idx, delta);
-			} else if (val_idx > (int64_t)row_idx) {
-				delta = idx_t(val_idx - row_idx);
-				val_idx = FindNextStart(ignore_nulls, row_idx + 1, bounds.partition_end, delta);
-			}
-			// else offset is zero, so don't move.
-
-			if (!delta) {
-				CopyCell(payload_collection, 0, val_idx, result, output_offset);
-			} else if (wexpr.default_expr) {
-				leadlag_default.CopyCell(result, output_offset);
-			} else {
-				FlatVector::SetNull(result, output_offset, true);
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_FIRST_VALUE: {
-			//	Same as NTH_VALUE(..., 1)
-			idx_t n = 1;
-			const auto first_idx = FindNextStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-			if (!n) {
-				CopyCell(payload_collection, 0, first_idx, result, output_offset);
-			} else {
-				FlatVector::SetNull(result, output_offset, true);
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_LAST_VALUE: {
-			idx_t n = 1;
-			const auto last_idx = FindPrevStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-			if (!n) {
-				CopyCell(payload_collection, 0, last_idx, result, output_offset);
-			} else {
-				FlatVector::SetNull(result, output_offset, true);
-			}
-			break;
-		}
-		case ExpressionType::WINDOW_NTH_VALUE: {
-			D_ASSERT(payload_collection.ColumnCount() == 2);
-			// Returns value evaluated at the row that is the n'th row of the window frame (counting from 1);
-			// returns NULL if there is no such row.
-			if (CellIsNull(payload_collection, 1, row_idx)) {
-				FlatVector::SetNull(result, output_offset, true);
-			} else {
-				auto n_param = GetCell<int64_t>(payload_collection, 1, row_idx);
-				if (n_param < 1) {
-					FlatVector::SetNull(result, output_offset, true);
-				} else {
-					auto n = idx_t(n_param);
-					const auto nth_index = FindNextStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-					if (!n) {
-						CopyCell(payload_collection, 0, nth_index, result, output_offset);
-					} else {
-						FlatVector::SetNull(result, output_offset, true);
-					}
-				}
-			}
-			break;
-		}
-		default:
-			throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.type));
-		}
-	}
-
-	result.Verify(input_chunk.size());
-}
-
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
@@ -1060,9 +124,11 @@ SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk,
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalWindow::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<WindowLocalSinkState>();
+SinkCombineResultType PhysicalWindow::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
 	lstate.Combine();
+
+	return SinkCombineResultType::FINISHED;
 }
 
 unique_ptr<LocalSinkState> PhysicalWindow::GetLocalSinkState(ExecutionContext &context) const {
@@ -1075,8 +141,8 @@ unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &co
 }
 
 SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          GlobalSinkState &gstate_p) const {
-	auto &state = gstate_p.Cast<WindowGlobalSinkState>();
+                                          OperatorSinkFinalizeInput &input) const {
+	auto &state = input.global_state.Cast<WindowGlobalSinkState>();
 
 	//	Did we get any data?
 	if (!state.global_partition->count) {
@@ -1106,64 +172,97 @@ SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
+class WindowPartitionSourceState;
+
 class WindowGlobalSourceState : public GlobalSourceState {
 public:
-	explicit WindowGlobalSourceState(WindowGlobalSinkState &gsink) : gsink(*gsink.global_partition), next_bin(0) {
-	}
+	using HashGroupSourcePtr = unique_ptr<WindowPartitionSourceState>;
+	using ScannerPtr = unique_ptr<RowDataCollectionScanner>;
+	using Task = std::pair<WindowPartitionSourceState *, ScannerPtr>;
 
-	PartitionGlobalSinkState &gsink;
-	//! The output read position.
-	atomic<idx_t> next_bin;
+	WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p);
+
+	//! Get the next task
+	Task NextTask(idx_t hash_bin);
+
+	//! Context for executing computations
+	ClientContext &context;
+	//! All the sunk data
+	WindowGlobalSinkState &gsink;
+	//! The next group to build.
+	atomic<idx_t> next_build;
+	//! The built groups
+	vector<HashGroupSourcePtr> built;
+	//! Serialise access to the built hash groups
+	mutable mutex built_lock;
+	//! The number of unfinished tasks
+	atomic<idx_t> tasks_remaining;
 
 public:
 	idx_t MaxThreads() override {
-		// If there is only one partition, we have to process it on one thread.
-		if (!gsink.grouping_data) {
-			return 1;
-		}
+		return tasks_remaining;
+	}
 
-		// If there is not a lot of data, process serially.
-		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
-			return 1;
+private:
+	Task CreateTask(idx_t hash_bin);
+	Task StealWork();
+};
+
+WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p)
+    : context(context_p), gsink(gsink_p), next_build(0), tasks_remaining(0) {
+	auto &hash_groups = gsink.global_partition->hash_groups;
+
+	auto &gpart = gsink.global_partition;
+	if (hash_groups.empty()) {
+		//	OVER()
+		built.resize(1);
+		if (gpart->rows) {
+			tasks_remaining += gpart->rows->blocks.size();
 		}
+	} else {
+		built.resize(hash_groups.size());
+		idx_t batch_base = 0;
+		for (auto &hash_group : hash_groups) {
+			if (!hash_group) {
+				continue;
+			}
+			auto &global_sort_state = *hash_group->global_sort;
+			if (global_sort_state.sorted_blocks.empty()) {
+				continue;
+			}
+
+			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
+			auto &sb = *global_sort_state.sorted_blocks[0];
+			auto &sd = *sb.payload_data;
+			tasks_remaining += sd.data_blocks.size();
 
-		return gsink.hash_groups.size();
+			hash_group->batch_base = batch_base;
+			batch_base += sd.data_blocks.size();
+		}
 	}
-};
+}
 
-// Per-thread read state
-class WindowLocalSourceState : public LocalSourceState {
+// Per-bin evaluation state (build and evaluate)
+class WindowPartitionSourceState {
 public:
 	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
-	using WindowExecutorPtr = unique_ptr<WindowExecutor>;
-	using WindowExecutors = vector<WindowExecutorPtr>;
+	using ExecutorPtr = unique_ptr<WindowExecutor>;
+	using Executors = vector<ExecutorPtr>;
 
-	WindowLocalSourceState(const PhysicalWindow &op_p, ExecutionContext &context, WindowGlobalSourceState &gsource)
-	    : context(context.client), op(op_p), gsink(gsource.gsink) {
-
-		vector<LogicalType> output_types;
-		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>();
-			output_types.emplace_back(wexpr.return_type);
-		}
-		output_chunk.Initialize(Allocator::Get(context.client), output_types);
-
-		const auto &input_types = gsink.payload_types;
-		layout.Initialize(input_types);
-		input_chunk.Initialize(gsink.allocator, input_types);
+	WindowPartitionSourceState(ClientContext &context, WindowGlobalSourceState &gsource)
+	    : context(context), op(gsource.gsink.op), gsource(gsource), read_block_idx(0), unscanned(0) {
+		layout.Initialize(gsource.gsink.global_partition->payload_types);
 	}
 
+	unique_ptr<RowDataCollectionScanner> GetScanner() const;
 	void MaterializeSortedData();
-	void GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin);
-	void Scan(DataChunk &chunk);
+	void BuildPartition(WindowGlobalSinkState &gstate, const idx_t hash_bin);
 
-	HashGroupPtr hash_group;
 	ClientContext &context;
 	const PhysicalWindow &op;
+	WindowGlobalSourceState &gsource;
 
-	PartitionGlobalSinkState &gsink;
-
+	HashGroupPtr hash_group;
 	//! The generated input chunks
 	unique_ptr<RowDataCollection> rows;
 	unique_ptr<RowDataCollection> heap;
@@ -1174,20 +273,21 @@ public:
 	//! The order boundary mask
 	vector<validity_t> order_bits;
 	ValidityMask order_mask;
+	//! External paging
+	bool external;
 	//! The current execution functions
-	WindowExecutors window_execs;
+	Executors executors;
 
-	//! The read partition
+	//! The bin number
 	idx_t hash_bin;
-	//! The read cursor
-	unique_ptr<RowDataCollectionScanner> scanner;
-	//! Buffer for the inputs
-	DataChunk input_chunk;
-	//! Buffer for window results
-	DataChunk output_chunk;
+
+	//! The next block to read.
+	mutable atomic<idx_t> read_block_idx;
+	//! The number of remaining unscanned blocks.
+	atomic<idx_t> unscanned;
 };
 
-void WindowLocalSourceState::MaterializeSortedData() {
+void WindowPartitionSourceState::MaterializeSortedData() {
 	auto &global_sort_state = *hash_group->global_sort;
 	if (global_sort_state.sorted_blocks.empty()) {
 		return;
@@ -1226,7 +326,21 @@ void WindowLocalSourceState::MaterializeSortedData() {
 	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
 }
 
-void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
+unique_ptr<RowDataCollectionScanner> WindowPartitionSourceState::GetScanner() const {
+	auto &gsink = *gsource.gsink.global_partition;
+	if ((gsink.rows && !hash_bin) || hash_bin < gsink.hash_groups.size()) {
+		const auto block_idx = read_block_idx++;
+		if (block_idx >= rows->blocks.size()) {
+			return nullptr;
+		}
+		//	Second pass can flush
+		--gsource.tasks_remaining;
+		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, true);
+	}
+	return nullptr;
+}
+
+void WindowPartitionSourceState::BuildPartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
 	//	Get rid of any stale data
 	hash_bin = hash_bin_p;
 
@@ -1236,11 +350,12 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	// 3. Multiple partitions (sorting and hashing)
 
 	//	How big is the partition?
+	auto &gpart = *gsource.gsink.global_partition;
 	idx_t count = 0;
-	if (hash_bin < gsink.hash_groups.size() && gsink.hash_groups[hash_bin]) {
-		count = gsink.hash_groups[hash_bin]->count;
-	} else if (gsink.rows && !hash_bin) {
-		count = gsink.count;
+	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;
 	} else {
 		return;
 	}
@@ -1256,19 +371,20 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	order_mask.Initialize(order_bits.data());
 
 	// Scan the sorted data into new Collections
-	auto external = gsink.external;
-	if (gsink.rows && !hash_bin) {
+	external = gpart.external;
+	if (gpart.rows && !hash_bin) {
 		// Simple mask
 		partition_mask.SetValidUnsafe(0);
 		order_mask.SetValidUnsafe(0);
 		//	No partition - align the heap blocks with the row blocks
-		rows = gsink.rows->CloneEmpty(gsink.rows->keep_pinned);
-		heap = gsink.strings->CloneEmpty(gsink.strings->keep_pinned);
-		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gsink.rows, *gsink.strings, layout);
+		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 < gsink.hash_groups.size() && gsink.hash_groups[hash_bin]) {
+	} else if (hash_bin < gpart.hash_groups.size()) {
 		// Overwrite the collections with the sorted data
-		hash_group = std::move(gsink.hash_groups[hash_bin]);
+		D_ASSERT(gpart.hash_groups[hash_bin].get());
+		hash_group = std::move(gpart.hash_groups[hash_bin]);
 		hash_group->ComputeMasks(partition_mask, order_mask);
 		external = hash_group->global_sort->external;
 		MaterializeSortedData();
@@ -1277,17 +393,18 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	}
 
 	// Create the executors for each function
-	window_execs.clear();
+	executors.clear();
 	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 = make_uniq<WindowExecutor>(wexpr, context, partition_mask, count);
-		window_execs.emplace_back(std::move(wexec));
+		auto wexec = WindowExecutorFactory(wexpr, context, partition_mask, order_mask, count, gstate.mode);
+		executors.emplace_back(std::move(wexec));
 	}
 
 	//	First pass over the input without flushing
-	//	TODO: Factor out the constructor data as global state
-	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
+	DataChunk input_chunk;
+	input_chunk.Initialize(gpart.allocator, gpart.payload_types);
+	auto scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
 	idx_t input_idx = 0;
 	while (true) {
 		input_chunk.Reset();
@@ -1297,38 +414,221 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 		}
 
 		//	TODO: Parallelization opportunity
-		for (auto &wexec : window_execs) {
+		for (auto &wexec : executors) {
 			wexec->Sink(input_chunk, input_idx, scanner->Count());
 		}
 		input_idx += input_chunk.size();
 	}
 
 	//	TODO: Parallelization opportunity
-	for (auto &wexec : window_execs) {
-		wexec->Finalize(gstate.mode);
+	for (auto &wexec : executors) {
+		wexec->Finalize();
 	}
 
 	// External scanning assumes all blocks are swizzled.
 	scanner->ReSwizzle();
 
-	//	Second pass can flush
-	scanner->Reset(true);
+	//	Start the block countdown
+	unscanned = rows->blocks.size();
+}
+
+// Per-thread scan state
+class WindowLocalSourceState : public LocalSourceState {
+public:
+	using ReadStatePtr = unique_ptr<WindowExecutorState>;
+	using ReadStates = vector<ReadStatePtr>;
+
+	explicit WindowLocalSourceState(WindowGlobalSourceState &gsource);
+	void UpdateBatchIndex();
+	bool NextPartition();
+	void Scan(DataChunk &chunk);
+
+	//! The shared source state
+	WindowGlobalSourceState &gsource;
+	//! The current bin being processed
+	idx_t hash_bin;
+	//! The current batch index (for output reordering)
+	idx_t batch_index;
+	//! The current source being processed
+	optional_ptr<WindowPartitionSourceState> partition_source;
+	//! The read cursor
+	unique_ptr<RowDataCollectionScanner> scanner;
+	//! Buffer for the inputs
+	DataChunk input_chunk;
+	//! Executor read states.
+	ReadStates read_states;
+	//! Buffer for window results
+	DataChunk output_chunk;
+};
+
+WindowLocalSourceState::WindowLocalSourceState(WindowGlobalSourceState &gsource)
+    : gsource(gsource), hash_bin(gsource.built.size()), batch_index(0) {
+	auto &gsink = *gsource.gsink.global_partition;
+	auto &op = gsource.gsink.op;
+
+	input_chunk.Initialize(gsink.allocator, gsink.payload_types);
+
+	vector<LogicalType> output_types;
+	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>();
+		output_types.emplace_back(wexpr.return_type);
+	}
+	output_chunk.Initialize(Allocator::Get(gsource.context), output_types);
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::CreateTask(idx_t hash_bin) {
+	//	Build outside the lock so no one tries to steal before we are done.
+	auto partition_source = make_uniq<WindowPartitionSourceState>(context, *this);
+	partition_source->BuildPartition(gsink, hash_bin);
+	Task result(partition_source.get(), partition_source->GetScanner());
+
+	//	Is there any data to scan?
+	if (result.second) {
+		lock_guard<mutex> built_guard(built_lock);
+		built[hash_bin] = std::move(partition_source);
+
+		return result;
+	}
+
+	return Task();
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::StealWork() {
+	for (idx_t hash_bin = 0; hash_bin < built.size(); ++hash_bin) {
+		lock_guard<mutex> built_guard(built_lock);
+		auto &partition_source = built[hash_bin];
+		if (!partition_source) {
+			continue;
+		}
+
+		Task result(partition_source.get(), partition_source->GetScanner());
+
+		//	Is there any data to scan?
+		if (result.second) {
+			return result;
+		}
+	}
+
+	//	Nothing to steal
+	return Task();
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::NextTask(idx_t hash_bin) {
+	auto &hash_groups = gsink.global_partition->hash_groups;
+	const auto bin_count = built.size();
+
+	//	Flush unneeded data
+	if (hash_bin < bin_count) {
+		//	Lock and delete when all blocks have been scanned
+		//	We do this here instead of in NextScan so the WindowLocalSourceState
+		//	has a chance to delete its state objects first,
+		//	which may reference the partition_source
+
+		//	Delete data outside the lock in case it is slow
+		HashGroupSourcePtr killed;
+		lock_guard<mutex> built_guard(built_lock);
+		auto &partition_source = built[hash_bin];
+		if (partition_source && !partition_source->unscanned) {
+			killed = std::move(partition_source);
+		}
+	}
+
+	hash_bin = next_build++;
+	if (hash_bin < bin_count) {
+		//	Find a non-empty hash group.
+		for (; hash_bin < hash_groups.size(); hash_bin = next_build++) {
+			if (hash_groups[hash_bin]) {
+				auto result = CreateTask(hash_bin);
+				if (result.second) {
+					return result;
+				}
+			}
+		}
+
+		//	OVER() doesn't have a hash_group
+		if (hash_groups.empty()) {
+			auto result = CreateTask(hash_bin);
+			if (result.second) {
+				return result;
+			}
+		}
+	}
+
+	//	Work stealing
+	while (!context.interrupted && tasks_remaining) {
+		auto result = StealWork();
+		if (result.second) {
+			return result;
+		}
+
+		//	If there is nothing to steal but there are unfinished partitions,
+		//	yield until any pending builds are done.
+		TaskScheduler::GetScheduler(context).YieldThread();
+	}
+
+	return Task();
+}
+
+void WindowLocalSourceState::UpdateBatchIndex() {
+	D_ASSERT(partition_source);
+	D_ASSERT(scanner.get());
+
+	batch_index = partition_source->hash_group ? partition_source->hash_group->batch_base : 0;
+	batch_index += scanner->BlockIndex();
+}
+
+bool WindowLocalSourceState::NextPartition() {
+	//	Release old states before the source
+	scanner.reset();
+	read_states.clear();
+
+	//	Get a partition_source that is not finished
+	while (!scanner) {
+		auto task = gsource.NextTask(hash_bin);
+		if (!task.first) {
+			return false;
+		}
+		partition_source = task.first;
+		scanner = std::move(task.second);
+		hash_bin = partition_source->hash_bin;
+		UpdateBatchIndex();
+	}
+
+	for (auto &wexec : partition_source->executors) {
+		read_states.emplace_back(wexec->GetExecutorState());
+	}
+
+	return true;
 }
 
 void WindowLocalSourceState::Scan(DataChunk &result) {
 	D_ASSERT(scanner);
 	if (!scanner->Remaining()) {
-		return;
+		lock_guard<mutex> built_guard(gsource.built_lock);
+		--partition_source->unscanned;
+		scanner = partition_source->GetScanner();
+
+		if (!scanner) {
+			partition_source = nullptr;
+			read_states.clear();
+			return;
+		}
+
+		UpdateBatchIndex();
 	}
 
 	const auto position = scanner->Scanned();
 	input_chunk.Reset();
 	scanner->Scan(input_chunk);
 
+	auto &executors = partition_source->executors;
 	output_chunk.Reset();
-	for (idx_t expr_idx = 0; expr_idx < window_execs.size(); ++expr_idx) {
-		auto &executor = *window_execs[expr_idx];
-		executor.Evaluate(position, input_chunk, output_chunk.data[expr_idx], partition_mask, order_mask);
+	for (idx_t expr_idx = 0; expr_idx < executors.size(); ++expr_idx) {
+		auto &executor = *executors[expr_idx];
+		auto &lstate = *read_states[expr_idx];
+		auto &result = output_chunk.data[expr_idx];
+		executor.Evaluate(position, input_chunk, result, lstate);
 	}
 	output_chunk.SetCardinality(input_chunk);
 	output_chunk.Verify();
@@ -1345,43 +645,42 @@ void WindowLocalSourceState::Scan(DataChunk &result) {
 }
 
 unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<WindowGlobalSourceState>();
-	return make_uniq<WindowLocalSourceState>(*this, context, gstate);
+                                                                 GlobalSourceState &gsource_p) const {
+	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
+	return make_uniq<WindowLocalSourceState>(gsource);
 }
 
 unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &context) const {
 	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowGlobalSourceState>(gsink);
+	return make_uniq<WindowGlobalSourceState>(context, gsink);
+}
+
+bool PhysicalWindow::SupportsBatchIndex() const {
+	//	We can only preserve order for single partitioning
+	//	or work stealing causes out of order batch numbers
+	auto &wexpr = select_list[0]->Cast<BoundWindowExpression>();
+	return wexpr.partitions.empty() && !wexpr.orders.empty();
+}
+
+OrderPreservationType PhysicalWindow::SourceOrder() const {
+	return SupportsBatchIndex() ? OrderPreservationType::FIXED_ORDER : OrderPreservationType::NO_ORDER;
+}
+
+idx_t PhysicalWindow::GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
+                                    LocalSourceState &lstate_p) const {
+	auto &lstate = lstate_p.Cast<WindowLocalSourceState>();
+	return lstate.batch_index;
 }
 
 SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
                                          OperatorSourceInput &input) const {
 	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
-	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
-	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-
-	auto &hash_groups = gsink.global_partition->hash_groups;
-	const auto bin_count = hash_groups.empty() ? 1 : hash_groups.size();
-
 	while (chunk.size() == 0) {
 		//	Move to the next bin if we are done.
-		while (!lsource.scanner || !lsource.scanner->Remaining()) {
-			lsource.scanner.reset();
-			lsource.rows.reset();
-			lsource.heap.reset();
-			lsource.hash_group.reset();
-			auto hash_bin = gsource.next_bin++;
-			if (hash_bin >= bin_count) {
+		while (!lsource.scanner) {
+			if (!lsource.NextPartition()) {
 				return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
 			}
-
-			for (; hash_bin < hash_groups.size(); hash_bin = gsource.next_bin++) {
-				if (hash_groups[hash_bin]) {
-					break;
-				}
-			}
-			lsource.GeneratePartition(gsink, hash_bin);
 		}
 
 		lsource.Scan(chunk);