duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -1,8 +1,7 @@
 #include "duckdb/function/window/window_naive_aggregator.hpp"
-#include "duckdb/common/sorting/sort.hpp"
+#include "duckdb/common/sort/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"
 
@@ -22,38 +21,38 @@ WindowNaiveAggregator::WindowNaiveAggregator(const WindowAggregateExecutor &exec
 WindowNaiveAggregator::~WindowNaiveAggregator() {
 }
 
-class WindowNaiveLocalState : public WindowAggregatorLocalState {
+class WindowNaiveState : public WindowAggregatorLocalState {
 public:
 	struct HashRow {
-		explicit HashRow(WindowNaiveLocalState &state) : state(state) {
+		explicit HashRow(WindowNaiveState &state) : state(state) {
 		}
 
 		inline size_t operator()(const idx_t &i) const {
 			return state.Hash(i);
 		}
 
-		WindowNaiveLocalState &state;
+		WindowNaiveState &state;
 	};
 
 	struct EqualRow {
-		explicit EqualRow(WindowNaiveLocalState &state) : state(state) {
+		explicit EqualRow(WindowNaiveState &state) : state(state) {
 		}
 
 		inline bool operator()(const idx_t &lhs, const idx_t &rhs) const {
 			return state.KeyEqual(lhs, rhs);
 		}
 
-		WindowNaiveLocalState &state;
+		WindowNaiveState &state;
 	};
 
 	using RowSet = std::unordered_set<idx_t, HashRow, EqualRow>;
 
-	WindowNaiveLocalState(ExecutionContext &context, const WindowNaiveAggregator &aggregator);
+	explicit WindowNaiveState(const WindowNaiveAggregator &gsink);
 
-	void Finalize(ExecutionContext &context, WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
+	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
 
-	void Evaluate(ExecutionContext &context, const WindowAggregatorGlobalState &gsink, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx, InterruptState &interrupt);
+	void Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx);
 
 protected:
 	//! Flush the accumulated intermediate states into the result states
@@ -86,20 +85,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_sink;
+	DataChunk orderby_sort;
 	//! Reusable sort payload chunk
-	DataChunk orderby_scan;
+	DataChunk orderby_payload;
 	//! Reusable sort key slicer
 	SelectionVector orderby_sel;
+	//! Reusable payload layout.
+	RowLayout payload_layout;
 };
 
-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) {
+WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p)
+    : aggregator(aggregator_p), state(aggregator.state_size * STANDARD_VECTOR_SIZE), statef(LogicalType::POINTER),
+      statep((LogicalType::POINTER)), flush_count(0), hashes(LogicalType::HASH) {
 	InitSubFrames(frames, aggregator.exclude_mode);
 
 	update_sel.Initialize();
@@ -114,11 +113,17 @@ WindowNaiveLocalState::WindowNaiveLocalState(ExecutionContext &context, const Wi
 		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 WindowNaiveLocalState::Finalize(ExecutionContext &context, WindowAggregatorGlobalState &gastate,
-                                     CollectionPtr collection) {
-	WindowAggregatorLocalState::Finalize(context, gastate, collection);
+void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
+	WindowAggregatorLocalState::Finalize(gastate, collection);
 
 	//	Set up the comparison scanner just in case
 	if (!comparer) {
@@ -128,35 +133,17 @@ void WindowNaiveLocalState::Finalize(ExecutionContext &context, WindowAggregator
 	//	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);
-		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();
+		orderby_sort.Initialize(BufferAllocator::Get(gastate.context), arg_orderer->chunk.GetTypes());
 	}
 
 	// Initialise the chunks
 	const auto types = cursor->chunk.GetTypes();
 	if (leaves.ColumnCount() == 0 && !types.empty()) {
-		leaves.Initialize(BufferAllocator::Get(context.client), types);
+		leaves.Initialize(BufferAllocator::Get(gastate.context), types);
 	}
 }
 
-void WindowNaiveLocalState::FlushStates(const WindowAggregatorGlobalState &gsink) {
+void WindowNaiveState::FlushStates(const WindowAggregatorGlobalState &gsink) {
 	if (!flush_count) {
 		return;
 	}
@@ -171,7 +158,7 @@ void WindowNaiveLocalState::FlushStates(const WindowAggregatorGlobalState &gsink
 	flush_count = 0;
 }
 
-size_t WindowNaiveLocalState::Hash(idx_t rid) {
+size_t WindowNaiveState::Hash(idx_t rid) {
 	D_ASSERT(cursor->RowIsVisible(rid));
 	auto s = cursor->RowOffset(rid);
 	auto &scanned = cursor->chunk;
@@ -182,7 +169,7 @@ size_t WindowNaiveLocalState::Hash(idx_t rid) {
 	return *FlatVector::GetData<hash_t>(hashes);
 }
 
-bool WindowNaiveLocalState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
+bool WindowNaiveState::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;
@@ -219,9 +206,8 @@ bool WindowNaiveLocalState::KeyEqual(const idx_t &lidx, const idx_t &ridx) {
 	return true;
 }
 
-void WindowNaiveLocalState::Evaluate(ExecutionContext &context, const WindowAggregatorGlobalState &gsink,
-                                     const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
-                                     InterruptState &interrupt) {
+void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const DataChunk &bounds, Vector &result,
+                                idx_t count, idx_t row_idx) {
 	const auto &aggr = gsink.aggr;
 	auto &filter_mask = gsink.filter_mask;
 	const auto types = cursor->chunk.GetTypes();
@@ -242,12 +228,14 @@ void WindowNaiveLocalState::Evaluate(ExecutionContext &context, const WindowAggr
 
 		// 	Sort the input rows by the argument
 		if (arg_orderer) {
-			auto global_sink = sort->GetGlobalSinkState(context.client);
-			auto local_sink = sort->GetLocalSinkState(context);
-			OperatorSinkInput sink {*global_sink, *local_sink, interrupt};
+			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);
 
 			idx_t orderby_count = 0;
-			auto orderby_row = FlatVector::GetData<idx_t>(orderby_sink.data.back());
+			auto orderby_row = FlatVector::GetData<idx_t>(orderby_payload.data[0]);
 			for (const auto &frame : frames) {
 				for (auto f = frame.start; f < frame.end; ++f) {
 					//	FILTER before the ORDER BY
@@ -257,45 +245,43 @@ void WindowNaiveLocalState::Evaluate(ExecutionContext &context, const WindowAggr
 
 					if (!arg_orderer->RowIsVisible(f) || orderby_count >= STANDARD_VECTOR_SIZE) {
 						if (orderby_count) {
-							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_sort.Reference(arg_orderer->chunk);
+							orderby_sort.Slice(orderby_sel, orderby_count);
+							orderby_payload.SetCardinality(orderby_count);
+							local_sort.SinkChunk(orderby_sort, orderby_payload);
 						}
 						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) {
-				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_sort.Reference(arg_orderer->chunk);
+				orderby_sort.Slice(orderby_sel, orderby_count);
+				orderby_payload.SetCardinality(orderby_count);
+				local_sort.SinkChunk(orderby_sort, orderby_payload);
 			}
 
-			OperatorSinkCombineInput combine {*global_sink, *local_sink, interrupt};
-			sort->Combine(context, combine);
-
-			OperatorSinkFinalizeInput finalize {*global_sink, interrupt};
-			sort->Finalize(context.client, finalize);
+			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);
+			}
 
-			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) {
+			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) {
 					const auto f = orderby_row[i];
 					//	Seek to the current position
 					if (!cursor->RowIsVisible(f)) {
@@ -360,23 +346,15 @@ void WindowNaiveLocalState::Evaluate(ExecutionContext &context, const WindowAggr
 	}
 }
 
-unique_ptr<LocalSinkState> WindowNaiveAggregator::GetLocalState(ExecutionContext &context,
-                                                                const GlobalSinkState &gstate) const {
-	return make_uniq<WindowNaiveLocalState>(context, *this);
+unique_ptr<WindowAggregatorState> WindowNaiveAggregator::GetLocalState(const WindowAggregatorState &gstate) const {
+	return make_uniq<WindowNaiveState>(*this);
 }
 
-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;
+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);
 }
 
 } // namespace duckdb

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

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