duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/function/window/window_naive_aggregator.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/function/window/window_naive_aggregator.hpp"
-#include "duckdb/common/sort/sort.hpp"
+#include "duckdb/common/sorting/sort.hpp"
 #include "duckdb/function/window/window_collection.hpp"
 #include "duckdb/function/window/window_shared_expressions.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
 #include "duckdb/function/window/window_aggregate_function.hpp"
 
@@ -21,38 +22,38 @@ WindowNaiveAggregator::WindowNaiveAggregator(const WindowAggregateExecutor &exec
 WindowNaiveAggregator::~WindowNaiveAggregator() {
 }
 
-class WindowNaiveState : public WindowAggregatorLocalState {
+class WindowNaiveLocalState : public WindowAggregatorLocalState {
 public:
 	struct HashRow {
-		explicit HashRow(WindowNaiveState &state) : state(state) {
+		explicit HashRow(WindowNaiveLocalState &state) : state(state) {
 		}
 
 		inline size_t operator()(const idx_t &i) const {
 			return state.Hash(i);
 		}
 
-		WindowNaiveState &state;
+		WindowNaiveLocalState &state;
 	};
 
 	struct EqualRow {
-		explicit EqualRow(WindowNaiveState &state) : state(state) {
+		explicit EqualRow(WindowNaiveLocalState &state) : state(state) {
 		}
 
 		inline bool operator()(const idx_t &lhs, const idx_t &rhs) const {
 			return state.KeyEqual(lhs, rhs);
 		}
 
-		WindowNaiveState &state;
+		WindowNaiveLocalState &state;
 	};
 
 	using RowSet = std::unordered_set<idx_t, HashRow, EqualRow>;
 
-	explicit WindowNaiveState(const WindowNaiveAggregator &gsink);
+	WindowNaiveLocalState(ExecutionContext &context, const WindowNaiveAggregator &aggregator);
 
-	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
+	void Finalize(ExecutionContext &context, WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
 
-	void Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx);
+	void Evaluate(ExecutionContext &context, const WindowAggregatorGlobalState &gsink, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx, InterruptState &interrupt);
 
 protected:
 	//! Flush the accumulated intermediate states into the result states
@@ -85,20 +86,20 @@ protected:
 	unique_ptr<WindowCursor> comparer;
 
 	//! The state used for scanning ORDER BY values from the collection
+	unique_ptr<Sort> sort;
+	//! The order by collection
 	unique_ptr<WindowCursor> arg_orderer;
 	//! Reusable sort key chunk
-	DataChunk orderby_sort;
+	DataChunk orderby_sink;
 	//! Reusable sort payload chunk
-	DataChunk orderby_payload;
+	DataChunk orderby_scan;
 	//! Reusable sort key slicer
 	SelectionVector orderby_sel;
-	//! Reusable payload layout.
-	RowLayout payload_layout;
 };
 
-WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p)
-    : aggregator(aggregator_p), state(aggregator.state_size * STANDARD_VECTOR_SIZE), statef(LogicalType::POINTER),
-      statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH) {
+WindowNaiveLocalState::WindowNaiveLocalState(ExecutionContext &context, const WindowNaiveAggregator &aggregator)
+    : WindowAggregatorLocalState(context), aggregator(aggregator), state(aggregator.state_size * STANDARD_VECTOR_SIZE),
+      statef(LogicalType::POINTER), statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH) {
 	InitSubFrames(frames, aggregator.exclude_mode);
 
 	update_sel.Initialize();
@@ -113,17 +114,11 @@ WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p)
 		fdata[i] = state_ptr;
 		state_ptr += aggregator.state_size;
 	}
-
-	//	Initialise any ORDER BY data
-	if (!aggregator.arg_order_idx.empty() && !arg_orderer) {
-		orderby_payload.Initialize(Allocator::DefaultAllocator(), {LogicalType::UBIGINT});
-		payload_layout.Initialize(orderby_payload.GetTypes());
-		orderby_sel.Initialize();
-	}
 }
 
-void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
-	WindowAggregatorLocalState::Finalize(gastate, collection);
+void WindowNaiveLocalState::Finalize(ExecutionContext &context, WindowAggregatorGlobalState &gastate,
+                                     CollectionPtr collection) {
+	WindowAggregatorLocalState::Finalize(context, gastate, collection);
 
 	//	Set up the comparison scanner just in case
 	if (!comparer) {
@@ -133,17 +128,35 @@ void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, Collection
 	//	Set up the argument ORDER BY scanner if needed
 	if (!aggregator.arg_order_idx.empty() && !arg_orderer) {
 		arg_orderer = make_uniq<WindowCursor>(*collection, aggregator.arg_order_idx);
-		orderby_sort.Initialize(BufferAllocator::Get(gastate.context), arg_orderer->chunk.GetTypes());
+		auto input_types = arg_orderer->chunk.GetTypes();
+		input_types.emplace_back(LogicalType::UBIGINT);
+		orderby_sink.Initialize(BufferAllocator::Get(gastate.client), input_types);
+
+		//	The sort expressions have already been computed, so we just need to reference them
+		vector<BoundOrderByNode> orders;
+		for (const auto &order_by : aggregator.wexpr.arg_orders) {
+			auto order = order_by.Copy();
+			const auto &type = order.expression->return_type;
+			order.expression = make_uniq<BoundReferenceExpression>(type, orders.size());
+			orders.emplace_back(std::move(order));
+		}
+
+		//	We only want the row numbers
+		vector<idx_t> projection_map(1, input_types.size() - 1);
+		orderby_scan.Initialize(BufferAllocator::Get(gastate.client), {input_types.back()});
+		sort = make_uniq<Sort>(context.client, orders, input_types, projection_map);
+
+		orderby_sel.Initialize();
 	}
 
 	// Initialise the chunks
 	const auto types = cursor->chunk.GetTypes();
 	if (leaves.ColumnCount() == 0 && !types.empty()) {
-		leaves.Initialize(BufferAllocator::Get(gastate.context), types);
+		leaves.Initialize(BufferAllocator::Get(context.client), types);
 	}
 }
 
-void WindowNaiveState::FlushStates(const WindowAggregatorGlobalState &gsink) {
+void WindowNaiveLocalState::FlushStates(const WindowAggregatorGlobalState &gsink) {
 	if (!flush_count) {
 		return;
 	}
@@ -158,7 +171,7 @@ void WindowNaiveState::FlushStates(const WindowAggregatorGlobalState &gsink) {
 	flush_count = 0;
 }
 
-size_t WindowNaiveState::Hash(idx_t rid) {
+size_t WindowNaiveLocalState::Hash(idx_t rid) {
 	D_ASSERT(cursor->RowIsVisible(rid));
 	auto s = cursor->RowOffset(rid);
 	auto &scanned = cursor->chunk;
@@ -169,7 +182,7 @@ size_t WindowNaiveState::Hash(idx_t rid) {
 	return *FlatVector::GetData<hash_t>(hashes);
 }
 
-bool WindowNaiveState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
+bool WindowNaiveLocalState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
 	//	One of the indices will be scanned, so make it the left one
 	auto lhs = lidx;
 	auto rhs = ridx;
@@ -206,8 +219,9 @@ bool WindowNaiveState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
 	return true;
 }
 
-void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result,
-                                idx_t count, idx_t row_idx) {
+void WindowNaiveLocalState::Evaluate(ExecutionContext &context, const WindowAggregatorGlobalState &gsink,
+                                     const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+                                     InterruptState &interrupt) {
 	const auto &aggr = gsink.aggr;
 	auto &filter_mask = gsink.filter_mask;
 	const auto types = cursor->chunk.GetTypes();
@@ -228,14 +242,12 @@ void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const
 
 		// 	Sort the input rows by the argument
 		if (arg_orderer) {
-			auto &context = aggregator.executor.context;
-			auto &orders = aggregator.wexpr.arg_orders;
-			GlobalSortState global_sort(context, orders, payload_layout);
-			LocalSortState local_sort;
-			local_sort.Initialize(global_sort, global_sort.buffer_manager);
+			auto global_sink = sort->GetGlobalSinkState(context.client);
+			auto local_sink = sort->GetLocalSinkState(context);
+			OperatorSinkInput sink {*global_sink, *local_sink, interrupt};
 
 			idx_t orderby_count = 0;
-			auto orderby_row = FlatVector::GetData<idx_t>(orderby_payload.data[0]);
+			auto orderby_row = FlatVector::GetData<idx_t>(orderby_sink.data.back());
 			for (const auto &frame : frames) {
 				for (auto f = frame.start; f < frame.end; ++f) {
 					//	FILTER before the ORDER BY
@@ -245,43 +257,45 @@ void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const
 
 					if (!arg_orderer->RowIsVisible(f) || orderby_count >= STANDARD_VECTOR_SIZE) {
 						if (orderby_count) {
-							orderby_sort.Reference(arg_orderer->chunk);
-							orderby_sort.Slice(orderby_sel, orderby_count);
-							orderby_payload.SetCardinality(orderby_count);
-							local_sort.SinkChunk(orderby_sort, orderby_payload);
+							for (column_t c = 0; c < arg_orderer->chunk.ColumnCount(); ++c) {
+								orderby_sink.data[c].Reference(arg_orderer->chunk.data[c]);
+							}
+							orderby_sink.Slice(orderby_sel, orderby_count);
+							sort->Sink(context, orderby_sink, sink);
+							orderby_sink.Reset();
 						}
 						orderby_count = 0;
 						arg_orderer->Seek(f);
+						//	Fill in the row numbers
+						for (idx_t i = 0; i < arg_orderer->chunk.size(); ++i) {
+							orderby_row[i] = arg_orderer->state.current_row_index + i;
+						}
 					}
-					orderby_row[orderby_count] = f;
 					orderby_sel.set_index(orderby_count++, arg_orderer->RowOffset(f));
 				}
 			}
 			if (orderby_count) {
-				orderby_sort.Reference(arg_orderer->chunk);
-				orderby_sort.Slice(orderby_sel, orderby_count);
-				orderby_payload.SetCardinality(orderby_count);
-				local_sort.SinkChunk(orderby_sort, orderby_payload);
+				for (column_t c = 0; c < arg_orderer->chunk.ColumnCount(); ++c) {
+					orderby_sink.data[c].Reference(arg_orderer->chunk.data[c]);
+				}
+				orderby_sink.Slice(orderby_sel, orderby_count);
+				sort->Sink(context, orderby_sink, sink);
+				orderby_sink.Reset();
 			}
 
-			global_sort.AddLocalState(local_sort);
-			if (global_sort.sorted_blocks.empty()) {
-				return;
-			}
-			global_sort.PrepareMergePhase();
-			while (global_sort.sorted_blocks.size() > 1) {
-				global_sort.InitializeMergeRound();
-				MergeSorter merge_sorter(global_sort, global_sort.buffer_manager);
-				merge_sorter.PerformInMergeRound();
-				global_sort.CompleteMergeRound(false);
-			}
+			OperatorSinkCombineInput combine {*global_sink, *local_sink, interrupt};
+			sort->Combine(context, combine);
+
+			OperatorSinkFinalizeInput finalize {*global_sink, interrupt};
+			sort->Finalize(context.client, finalize);
 
-			PayloadScanner scanner(global_sort);
-			while (scanner.Remaining()) {
-				orderby_payload.Reset();
-				scanner.Scan(orderby_payload);
-				orderby_row = FlatVector::GetData<idx_t>(orderby_payload.data[0]);
-				for (idx_t i = 0; i < orderby_payload.size(); ++i) {
+			auto global_source = sort->GetGlobalSourceState(context.client, *global_sink);
+			auto local_source = sort->GetLocalSourceState(context, *global_source);
+			OperatorSourceInput source {*global_source, *local_source, interrupt};
+			orderby_scan.Reset();
+			for (; SourceResultType::FINISHED != sort->GetData(context, orderby_scan, source); orderby_scan.Reset()) {
+				orderby_row = FlatVector::GetData<idx_t>(orderby_scan.data[0]);
+				for (idx_t i = 0; i < orderby_scan.size(); ++i) {
 					const auto f = orderby_row[i];
 					//	Seek to the current position
 					if (!cursor->RowIsVisible(f)) {
@@ -346,15 +360,23 @@ void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const
 	}
 }
 
-unique_ptr<WindowAggregatorState> WindowNaiveAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
-	return make_uniq<WindowNaiveState>(*this);
+unique_ptr<LocalSinkState> WindowNaiveAggregator::GetLocalState(ExecutionContext &context,
+                                                                const GlobalSinkState &gstate) const {
+	return make_uniq<WindowNaiveLocalState>(context, *this);
 }
 
-void WindowNaiveAggregator::Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate,
-                                     const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const {
-	const auto &gnstate = gsink.Cast<WindowAggregatorGlobalState>();
-	auto &lnstate = lstate.Cast<WindowNaiveState>();
-	lnstate.Evaluate(gnstate, bounds, result, count, row_idx);
+void WindowNaiveAggregator::Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count,
+                                     idx_t row_idx, OperatorSinkInput &sink) const {
+	const auto &gnstate = sink.global_state.Cast<WindowAggregatorGlobalState>();
+	auto &lnstate = sink.local_state.Cast<WindowNaiveLocalState>();
+	lnstate.Evaluate(context, gnstate, bounds, result, count, row_idx, sink.interrupt_state);
+}
+
+bool WindowNaiveAggregator::CanAggregate(const BoundWindowExpression &wexpr) {
+	if (!wexpr.aggregate || !wexpr.aggregate->CanAggregate()) {
+		return false;
+	}
+	return true;
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/window/window_rank_function.cpp

@@ -10,9 +10,9 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class WindowPeerGlobalState : public WindowExecutorGlobalState {
 public:
-	WindowPeerGlobalState(const WindowPeerExecutor &executor, const idx_t payload_count,
+	WindowPeerGlobalState(ClientContext &client, const WindowPeerExecutor &executor, const idx_t payload_count,
 	                      const ValidityMask &partition_mask, const ValidityMask &order_mask)
-	    : WindowExecutorGlobalState(executor, payload_count, partition_mask, order_mask) {
+	    : WindowExecutorGlobalState(client, executor, payload_count, partition_mask, order_mask) {
 		if (!executor.arg_order_idx.empty()) {
 			use_framing = true;
 
@@ -20,10 +20,9 @@ public:
 			//	(and the optimizer is enabled), then we can just use the partition ordering.
 			auto &wexpr = executor.wexpr;
 			auto &arg_orders = executor.wexpr.arg_orders;
-			const auto optimize = ClientConfig::GetConfig(executor.context).enable_optimizer;
+			const auto optimize = ClientConfig::GetConfig(client).enable_optimizer;
 			if (!optimize || BoundWindowExpression::GetSharedOrders(wexpr.orders, arg_orders) != arg_orders.size()) {
-				token_tree =
-				    make_uniq<WindowTokenTree>(executor.context, arg_orders, executor.arg_order_idx, payload_count);
+				token_tree = make_uniq<WindowTokenTree>(client, arg_orders, executor.arg_order_idx, payload_count);
 			}
 		}
 	}
@@ -39,20 +38,20 @@ public:
 // WindowPeerLocalState
 //===--------------------------------------------------------------------===//
 //	Base class for non-aggregate functions that use peer boundaries
-class WindowPeerLocalState : public WindowExecutorBoundsState {
+class WindowPeerLocalState : public WindowExecutorBoundsLocalState {
 public:
-	explicit WindowPeerLocalState(const WindowPeerGlobalState &gpstate)
-	    : WindowExecutorBoundsState(gpstate), gpstate(gpstate) {
+	WindowPeerLocalState(ExecutionContext &context, const WindowPeerGlobalState &gpstate)
+	    : WindowExecutorBoundsLocalState(context, gpstate), gpstate(gpstate) {
 		if (gpstate.token_tree) {
-			local_tree = gpstate.token_tree->GetLocalState();
+			local_tree = gpstate.token_tree->GetLocalState(context);
 		}
 	}
 
 	//! Accumulate the secondary sort values
-	void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx) override;
+	void Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
+	          OperatorSinkInput &sink) override;
 	//! Finish the sinking and prepare to scan
-	void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override;
+	void Finalize(ExecutionContext &context, CollectionPtr collection, OperatorSinkInput &sink) override;
 
 	void NextRank(idx_t partition_begin, idx_t peer_begin, idx_t row_idx);
 
@@ -63,25 +62,25 @@ public:
 	//! The corresponding global peer state
 	const WindowPeerGlobalState &gpstate;
 	//! The optional sorting state for secondary sorts
-	unique_ptr<WindowAggregatorState> local_tree;
+	unique_ptr<LocalSinkState> local_tree;
 };
 
-void WindowPeerLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-                                idx_t input_idx) {
-	WindowExecutorBoundsState::Sink(gstate, sink_chunk, coll_chunk, input_idx);
+void WindowPeerLocalState::Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk,
+                                idx_t input_idx, OperatorSinkInput &sink) {
+	WindowExecutorBoundsLocalState::Sink(context, sink_chunk, coll_chunk, input_idx, sink);
 
 	if (local_tree) {
 		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.SinkChunk(sink_chunk, input_idx, nullptr, 0);
+		local_tokens.Sink(context, sink_chunk, input_idx, nullptr, 0, sink.interrupt_state);
 	}
 }
 
-void WindowPeerLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) {
-	WindowExecutorBoundsState::Finalize(gstate, collection);
+void WindowPeerLocalState::Finalize(ExecutionContext &context, CollectionPtr collection, OperatorSinkInput &sink) {
+	WindowExecutorBoundsLocalState::Finalize(context, collection, sink);
 
 	if (local_tree) {
 		auto &local_tokens = local_tree->Cast<WindowMergeSortTreeLocalState>();
-		local_tokens.Sort();
+		local_tokens.Finalize(context, sink.interrupt_state);
 		local_tokens.window_tree.Build();
 	}
 }
@@ -102,52 +101,51 @@ void WindowPeerLocalState::NextRank(idx_t partition_begin, idx_t peer_begin, idx
 //===--------------------------------------------------------------------===//
 // WindowPeerExecutor
 //===--------------------------------------------------------------------===//
-WindowPeerExecutor::WindowPeerExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                       WindowSharedExpressions &shared)
-    : WindowExecutor(wexpr, context, shared) {
+WindowPeerExecutor::WindowPeerExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
+    : WindowExecutor(wexpr, shared) {
 
 	for (const auto &order : wexpr.arg_orders) {
 		arg_order_idx.emplace_back(shared.RegisterSink(order.expression));
 	}
 }
 
-unique_ptr<WindowExecutorGlobalState> WindowPeerExecutor::GetGlobalState(const idx_t payload_count,
-                                                                         const ValidityMask &partition_mask,
-                                                                         const ValidityMask &order_mask) const {
-	return make_uniq<WindowPeerGlobalState>(*this, payload_count, partition_mask, order_mask);
+unique_ptr<GlobalSinkState> WindowPeerExecutor::GetGlobalState(ClientContext &client, const idx_t payload_count,
+                                                               const ValidityMask &partition_mask,
+                                                               const ValidityMask &order_mask) const {
+	return make_uniq<WindowPeerGlobalState>(client, *this, payload_count, partition_mask, order_mask);
 }
 
-unique_ptr<WindowExecutorLocalState> WindowPeerExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowPeerLocalState>(gstate.Cast<WindowPeerGlobalState>());
+unique_ptr<LocalSinkState> WindowPeerExecutor::GetLocalState(ExecutionContext &context,
+                                                             const GlobalSinkState &gstate) const {
+	return make_uniq<WindowPeerLocalState>(context, gstate.Cast<WindowPeerGlobalState>());
 }
 
 //===--------------------------------------------------------------------===//
 // WindowRankExecutor
 //===--------------------------------------------------------------------===//
-WindowRankExecutor::WindowRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                       WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
+WindowRankExecutor::WindowRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
+    : WindowPeerExecutor(wexpr, shared) {
 }
 
-void WindowRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                          DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
-	auto rdata = FlatVector::GetData<uint64_t>(result);
+void WindowRankExecutor::EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count,
+                                          idx_t row_idx, OperatorSinkInput &sink) const {
+	auto &gpeer = sink.global_state.Cast<WindowPeerGlobalState>();
+	auto &lpeer = sink.local_state.Cast<WindowPeerLocalState>();
+	auto rdata = FlatVector::GetData<int64_t>(result);
 
 	if (gpeer.use_framing) {
 		auto frame_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_BEGIN]);
 		auto frame_end = FlatVector::GetData<const idx_t>(lpeer.bounds.data[FRAME_END]);
 		if (gpeer.token_tree) {
 			for (idx_t i = 0; i < count; ++i, ++row_idx) {
-				rdata[i] = gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx);
+				rdata[i] = UnsafeNumericCast<int64_t>(gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx));
 			}
 		} else {
 			auto peer_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_BEGIN]);
 			for (idx_t i = 0; i < count; ++i, ++row_idx) {
 				//	Clamp peer to the frame
 				const auto frame_peer_begin = MaxValue(frame_begin[i], peer_begin[i]);
-				rdata[i] = (frame_peer_begin - frame_begin[i]) + 1;
+				rdata[i] = UnsafeNumericCast<int64_t>((frame_peer_begin - frame_begin[i]) + 1);
 			}
 		}
 		return;
@@ -161,24 +159,23 @@ void WindowRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, Win
 
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		rdata[i] = lpeer.rank;
+		rdata[i] = UnsafeNumericCast<int64_t>(lpeer.rank);
 	}
 }
 
 //===--------------------------------------------------------------------===//
 // WindowDenseRankExecutor
 //===--------------------------------------------------------------------===//
-WindowDenseRankExecutor::WindowDenseRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                 WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
+WindowDenseRankExecutor::WindowDenseRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
+    : WindowPeerExecutor(wexpr, shared) {
 }
 
-void WindowDenseRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
+void WindowDenseRankExecutor::EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result,
+                                               idx_t count, idx_t row_idx, OperatorSinkInput &sink) const {
+	auto &gpeer = sink.global_state.Cast<WindowPeerGlobalState>();
+	auto &lpeer = sink.local_state.Cast<WindowPeerLocalState>();
 
-	auto &order_mask = gstate.order_mask;
+	auto &order_mask = gpeer.order_mask;
 	auto partition_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PARTITION_BEGIN]);
 	auto peer_begin = FlatVector::GetData<const idx_t>(lpeer.bounds.data[PEER_BEGIN]);
 	auto rdata = FlatVector::GetData<int64_t>(result);
@@ -231,9 +228,8 @@ void WindowDenseRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate
 //===--------------------------------------------------------------------===//
 // WindowPercentRankExecutor
 //===--------------------------------------------------------------------===//
-WindowPercentRankExecutor::WindowPercentRankExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                                     WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
+WindowPercentRankExecutor::WindowPercentRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
+    : WindowPeerExecutor(wexpr, shared) {
 }
 
 static inline double PercentRank(const idx_t begin, const idx_t end, const uint64_t rank) {
@@ -241,11 +237,10 @@ static inline double PercentRank(const idx_t begin, const idx_t end, const uint6
 	return denom > 0 ? ((double)rank - 1) / denom : 0;
 }
 
-void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                                 DataChunk &eval_chunk, Vector &result, idx_t count,
-                                                 idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
+void WindowPercentRankExecutor::EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result,
+                                                 idx_t count, idx_t row_idx, OperatorSinkInput &sink) const {
+	auto &gpeer = sink.global_state.Cast<WindowPeerGlobalState>();
+	auto &lpeer = sink.local_state.Cast<WindowPeerLocalState>();
 	auto rdata = FlatVector::GetData<double>(result);
 
 	if (gpeer.use_framing) {
@@ -284,9 +279,8 @@ void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gsta
 //===--------------------------------------------------------------------===//
 // WindowCumeDistExecutor
 //===--------------------------------------------------------------------===//
-WindowCumeDistExecutor::WindowCumeDistExecutor(BoundWindowExpression &wexpr, ClientContext &context,
-                                               WindowSharedExpressions &shared)
-    : WindowPeerExecutor(wexpr, context, shared) {
+WindowCumeDistExecutor::WindowCumeDistExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared)
+    : WindowPeerExecutor(wexpr, shared) {
 }
 
 static inline double CumeDist(const idx_t begin, const idx_t end, const idx_t peer_end) {
@@ -295,10 +289,10 @@ static inline double CumeDist(const idx_t begin, const idx_t end, const idx_t pe
 	return denom > 0 ? (num / denom) : 0;
 }
 
-void WindowCumeDistExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                              DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const {
-	auto &gpeer = gstate.Cast<WindowPeerGlobalState>();
-	auto &lpeer = lstate.Cast<WindowPeerLocalState>();
+void WindowCumeDistExecutor::EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result,
+                                              idx_t count, idx_t row_idx, OperatorSinkInput &sink) const {
+	auto &gpeer = sink.global_state.Cast<WindowPeerGlobalState>();
+	auto &lpeer = sink.local_state.Cast<WindowPeerLocalState>();
 	auto rdata = FlatVector::GetData<double>(result);
 
 	if (gpeer.use_framing) {