duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp

@@ -16,23 +16,22 @@ class WindowConstantAggregator : public WindowAggregator {
 public:
 	static bool CanAggregate(const BoundWindowExpression &wexpr);
 
-	static BoundWindowExpression &RebindAggregate(ClientContext &context, BoundWindowExpression &wexpr);
+	static BoundWindowExpression &RebindAggregate(ClientContext &client, BoundWindowExpression &wexpr);
 
 	WindowConstantAggregator(BoundWindowExpression &wexpr, WindowSharedExpressions &shared, ClientContext &context);
 	~WindowConstantAggregator() override {
 	}
 
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-	          DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-	          idx_t filtered) override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &context, idx_t group_count,
+	                                           const ValidityMask &partition_mask) const override;
+	void Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
+	          optional_ptr<SelectionVector> filter_sel, idx_t filtered, OperatorSinkInput &sink) override;
+	void Finalize(ExecutionContext &context, CollectionPtr collection, const FrameStats &stats,
+	              OperatorSinkInput &sink) override;
+
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
+	void Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+	              OperatorSinkInput &sink) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp

@@ -19,14 +19,14 @@ public:
 	WindowCustomAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 	~WindowCustomAggregator() override;
 
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &context, idx_t group_count,
+	                                           const ValidityMask &partition_mask) const override;
+	void Finalize(ExecutionContext &context, CollectionPtr collection, const FrameStats &stats,
+	              OperatorSinkInput &sink) override;
+
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
+	void Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+	              OperatorSinkInput &sink) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp

@@ -17,20 +17,20 @@ public:
 	static bool CanAggregate(const BoundWindowExpression &wexpr);
 
 	WindowDistinctAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared,
-	                         ClientContext &context);
+	                         ClientContext &client);
 
 	//	Build
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	void Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &sink_chunk, DataChunk &coll_chunk,
-	          idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered) override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &client, idx_t group_count,
+	                                           const ValidityMask &partition_mask) const override;
+	void Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
+	          optional_ptr<SelectionVector> filter_sel, idx_t filtered, OperatorSinkInput &sink) override;
+	void Finalize(ExecutionContext &context, CollectionPtr collection, const FrameStats &stats,
+	              OperatorSinkInput &sink) override;
 
 	//	Evaluate
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
+	void Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+	              OperatorSinkInput &sink) const override;
 
 	//! Context for sorting
 	ClientContext &context;

package/src/duckdb/src/include/duckdb/function/window/window_executor.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/execution/physical_operator_states.hpp"
 #include "duckdb/function/window/window_boundaries_state.hpp"
 #include "duckdb/function/window/window_collection.hpp"
 
@@ -17,33 +18,16 @@ class WindowCollection;
 
 struct WindowSharedExpressions;
 
-class WindowExecutorState {
-public:
-	WindowExecutorState() {};
-	virtual ~WindowExecutorState() {
-	}
-
-	template <class TARGET>
-	TARGET &Cast() {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<TARGET &>(*this);
-	}
-	template <class TARGET>
-	const TARGET &Cast() const {
-		DynamicCastCheck<TARGET>(this);
-		return reinterpret_cast<const TARGET &>(*this);
-	}
-};
-
 class WindowExecutor;
 
-class WindowExecutorGlobalState : public WindowExecutorState {
+class WindowExecutorGlobalState : public GlobalSinkState {
 public:
 	using CollectionPtr = optional_ptr<WindowCollection>;
 
-	WindowExecutorGlobalState(const WindowExecutor &executor, const idx_t payload_count,
+	WindowExecutorGlobalState(ClientContext &client, const WindowExecutor &executor, const idx_t payload_count,
 	                          const ValidityMask &partition_mask, const ValidityMask &order_mask);
 
+	ClientContext &client;
 	const WindowExecutor &executor;
 
 	const idx_t payload_count;
@@ -52,23 +36,24 @@ public:
 	vector<LogicalType> arg_types;
 };
 
-class WindowExecutorLocalState : public WindowExecutorState {
+class WindowExecutorLocalState : public LocalSinkState {
 public:
 	using CollectionPtr = optional_ptr<WindowCollection>;
 
-	explicit WindowExecutorLocalState(const WindowExecutorGlobalState &gstate);
+	WindowExecutorLocalState(ExecutionContext &context, const WindowExecutorGlobalState &gstate);
 
-	virtual void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx);
-	virtual void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection);
+	virtual void Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
+	                  OperatorSinkInput &sink);
+	virtual void Finalize(ExecutionContext &context, CollectionPtr collection, OperatorSinkInput &sink);
 
 	//! The state used for reading the range collection
 	unique_ptr<WindowCursor> range_cursor;
 };
 
-class WindowExecutorBoundsState : public WindowExecutorLocalState {
+class WindowExecutorBoundsLocalState : public WindowExecutorLocalState {
 public:
-	explicit WindowExecutorBoundsState(const WindowExecutorGlobalState &gstate);
-	~WindowExecutorBoundsState() override {
+	WindowExecutorBoundsLocalState(ExecutionContext &context, const WindowExecutorGlobalState &gstate);
+	~WindowExecutorBoundsLocalState() override {
 	}
 
 	virtual void UpdateBounds(WindowExecutorGlobalState &gstate, idx_t row_idx, DataChunk &eval_chunk,
@@ -85,26 +70,27 @@ class WindowExecutor {
 public:
 	using CollectionPtr = optional_ptr<WindowCollection>;
 
-	WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 	virtual ~WindowExecutor() {
 	}
 
-	virtual unique_ptr<WindowExecutorGlobalState>
-	GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask, const ValidityMask &order_mask) const;
-	virtual unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const;
+	virtual bool IgnoreNulls() const;
+
+	virtual unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &client, const idx_t payload_count,
+	                                                   const ValidityMask &partition_mask,
+	                                                   const ValidityMask &order_mask) const;
+	virtual unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const;
 
-	virtual void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
-	                  WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const;
+	virtual void Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
+	                  OperatorSinkInput &sink) const;
 
-	virtual void Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	                      CollectionPtr collection) const;
+	virtual void Finalize(ExecutionContext &context, CollectionPtr collection, OperatorSinkInput &sink) const;
 
-	void Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate,
-	              WindowExecutorGlobalState &gstate) const;
+	void Evaluate(ExecutionContext &context, idx_t row_idx, DataChunk &eval_chunk, Vector &result,
+	              OperatorSinkInput &sink) const;
 
 	// The function
 	const BoundWindowExpression &wexpr;
-	ClientContext &context;
 
 	// evaluate frame expressions, if needed
 	column_t boundary_start_idx = DConstants::INVALID_INDEX;
@@ -115,8 +101,8 @@ public:
 	column_t range_idx = DConstants::INVALID_INDEX;
 
 protected:
-	virtual void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-	                              DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const = 0;
+	virtual void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count,
+	                              idx_t row_idx, OperatorSinkInput &sink) const = 0;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_index_tree.hpp

@@ -16,7 +16,7 @@ class WindowIndexTree;
 
 class WindowIndexTreeLocalState : public WindowMergeSortTreeLocalState {
 public:
-	explicit WindowIndexTreeLocalState(WindowIndexTree &index_tree);
+	WindowIndexTreeLocalState(ExecutionContext &context, WindowIndexTree &index_tree);
 
 	//! Process sorted leaf data
 	void BuildLeaves() override;
@@ -33,7 +33,7 @@ public:
 	                const idx_t count);
 	~WindowIndexTree() override = default;
 
-	unique_ptr<WindowAggregatorState> GetLocalState() override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context) override;
 
 	//! Find the Nth index in the set of subframes
 	//! Returns {nth index, 0} or {nth offset, overflow}

package/src/duckdb/src/include/duckdb/function/window/window_merge_sort_tree.hpp

@@ -11,86 +11,88 @@
 #include "duckdb/execution/merge_sort_tree.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 
-#include "duckdb/function/window/window_aggregator.hpp"
-#include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/sort/partition_state.hpp"
+#include "duckdb/common/sorting/sort.hpp"
 
 namespace duckdb {
 
+enum class WindowMergeSortStage : uint8_t { INIT, COMBINE, FINALIZE, SORTED, FINISHED };
+
 class WindowMergeSortTree;
 
-class WindowMergeSortTreeLocalState : public WindowAggregatorState {
+class WindowMergeSortTreeLocalState : public LocalSinkState {
 public:
-	explicit WindowMergeSortTreeLocalState(WindowMergeSortTree &index_tree);
+	WindowMergeSortTreeLocalState(ExecutionContext &context, WindowMergeSortTree &index_tree);
 
 	//! Add a chunk to the local sort
-	void SinkChunk(DataChunk &chunk, const idx_t row_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
+	void Sink(ExecutionContext &context, DataChunk &chunk, const idx_t row_idx,
+	          optional_ptr<SelectionVector> filter_sel, idx_t filtered, InterruptState &interrupt);
 	//! Sort the data
-	void Sort();
+	void Finalize(ExecutionContext &context, InterruptState &interrupt);
 	//! Process sorted leaf data
 	virtual void BuildLeaves() = 0;
 
 	//! The index tree we are building
 	WindowMergeSortTree &window_tree;
 	//! Thread-local sorting data
-	optional_ptr<LocalSortState> local_sort;
-	//! Buffer for the sort keys
+	optional_ptr<LocalSinkState> local_sink;
+	//! Buffer for the sort data
 	DataChunk sort_chunk;
-	//! Buffer for the payload data
-	DataChunk payload_chunk;
 	//! Build stage
-	PartitionSortStage build_stage = PartitionSortStage::INIT;
+	WindowMergeSortStage build_stage = WindowMergeSortStage::INIT;
 	//! Build task number
 	idx_t build_task;
 
 private:
-	void ExecuteSortTask();
+	void ExecuteSortTask(ExecutionContext &context, InterruptState &interrupt);
 };
 
 class WindowMergeSortTree {
 public:
-	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
-	using LocalSortStatePtr = unique_ptr<LocalSortState>;
+	using GlobalSortStatePtr = unique_ptr<GlobalSinkState>;
+	using LocalSortStatePtr = unique_ptr<LocalSinkState>;
 
 	WindowMergeSortTree(ClientContext &context, const vector<BoundOrderByNode> &orders,
-	                    const vector<column_t> &sort_idx, const idx_t count, bool unique = false);
+	                    const vector<column_t> &order_idx, const idx_t count, bool unique = false);
 	virtual ~WindowMergeSortTree() = default;
 
-	virtual unique_ptr<WindowAggregatorState> GetLocalState() = 0;
+	virtual unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context) = 0;
 
 	//! Make a local sort for a thread
-	optional_ptr<LocalSortState> AddLocalSort();
+	optional_ptr<LocalSinkState> InitializeLocalSort(ExecutionContext &context) const;
 
 	//! Thread-safe post-sort cleanup
-	virtual void CleanupSort();
+	virtual void Finished();
 
 	//! Sort state machine
 	bool TryPrepareSortStage(WindowMergeSortTreeLocalState &lstate);
 	//! Build the MST in parallel from the sorted data
 	void Build();
 
-	//! The query context
-	ClientContext &context;
-	//! Thread memory limit
-	const idx_t memory_per_thread;
 	//! The column indices for sorting
-	const vector<column_t> sort_idx;
+	const vector<column_t> order_idx;
+	//! The sorted data schema
+	vector<LogicalType> scan_types;
+	vector<idx_t> scan_cols;
+	//! The sort key columns
+	vector<idx_t> key_cols;
+	//! The sort specification
+	unique_ptr<Sort> sort;
 	//! The sorted data
-	GlobalSortStatePtr global_sort;
+	GlobalSortStatePtr global_sink;
+	//! The resulting sorted data
+	unique_ptr<ColumnDataCollection> sorted;
 	//! Finalize guard
-	mutex lock;
+	mutable mutex lock;
 	//! Local sort set
-	vector<LocalSortStatePtr> local_sorts;
+	mutable vector<LocalSortStatePtr> local_sinks;
 	//! Finalize stage
-	atomic<PartitionSortStage> build_stage;
+	atomic<WindowMergeSortStage> build_stage;
 	//! Tasks launched
 	idx_t total_tasks = 0;
 	//! Tasks launched
 	idx_t tasks_assigned = 0;
 	//! Tasks landed
 	atomic<idx_t> tasks_completed;
-	//! The block starts (the scanner doesn't know this) plus the total count
-	vector<idx_t> block_starts;
 
 	// Merge sort trees for various sizes
 	// Smaller is probably not worth the effort.

package/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp

@@ -20,9 +20,11 @@ public:
 	WindowNaiveAggregator(const WindowAggregateExecutor &executor, WindowSharedExpressions &shared);
 	~WindowNaiveAggregator() override;
 
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
+	void Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+	              OperatorSinkInput &sink) const override;
+
+	static bool CanAggregate(const BoundWindowExpression &wexpr);
 
 	//! The parent executor
 	const WindowAggregateExecutor &executor;

package/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp

@@ -14,11 +14,12 @@ namespace duckdb {
 
 class WindowPeerExecutor : public WindowExecutor {
 public:
-	WindowPeerExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowPeerExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &context, const idx_t payload_count,
+	                                           const ValidityMask &partition_mask,
+	                                           const ValidityMask &order_mask) const override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
 
 	//! The column indices of any ORDER BY argument expressions
 	vector<column_t> arg_order_idx;
@@ -26,38 +27,38 @@ public:
 
 class WindowRankExecutor : public WindowPeerExecutor {
 public:
-	WindowRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 class WindowDenseRankExecutor : public WindowPeerExecutor {
 public:
-	WindowDenseRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowDenseRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 class WindowPercentRankExecutor : public WindowPeerExecutor {
 public:
-	WindowPercentRankExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowPercentRankExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 class WindowCumeDistExecutor : public WindowPeerExecutor {
 public:
-	WindowCumeDistExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowCumeDistExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp

@@ -14,11 +14,12 @@ namespace duckdb {
 
 class WindowRowNumberExecutor : public WindowExecutor {
 public:
-	WindowRowNumberExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowRowNumberExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
-	unique_ptr<WindowExecutorGlobalState> GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask,
-	                                                     const ValidityMask &order_mask) const override;
-	unique_ptr<WindowExecutorLocalState> GetLocalState(const WindowExecutorGlobalState &gstate) const override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &client, const idx_t payload_count,
+	                                           const ValidityMask &partition_mask,
+	                                           const ValidityMask &order_mask) const override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
 
 	//! The evaluation index of the NTILE column
 	column_t ntile_idx = DConstants::INVALID_INDEX;
@@ -26,18 +27,18 @@ public:
 	vector<column_t> arg_order_idx;
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 // NTILE is just scaled ROW_NUMBER
 class WindowNtileExecutor : public WindowRowNumberExecutor {
 public:
-	WindowNtileExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared);
+	WindowNtileExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
 protected:
-	void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk,
-	                      Vector &result, idx_t count, idx_t row_idx) const override;
+	void EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx,
+	                      OperatorSinkInput &sink) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp

@@ -18,14 +18,14 @@ public:
 
 	WindowSegmentTree(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared);
 
-	unique_ptr<WindowAggregatorState> GetGlobalState(ClientContext &context, idx_t group_count,
-	                                                 const ValidityMask &partition_mask) const override;
-	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
-	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-	              const FrameStats &stats) override;
-
-	void Evaluate(const WindowAggregatorState &gstate, WindowAggregatorState &lstate, const DataChunk &bounds,
-	              Vector &result, idx_t count, idx_t row_idx) const override;
+	unique_ptr<GlobalSinkState> GetGlobalState(ClientContext &context, idx_t group_count,
+	                                           const ValidityMask &partition_mask) const override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context, const GlobalSinkState &gstate) const override;
+	void Finalize(ExecutionContext &context, CollectionPtr collection, const FrameStats &stats,
+	              OperatorSinkInput &sink) override;
+
+	void Evaluate(ExecutionContext &context, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx,
+	              OperatorSinkInput &sink) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/window/window_token_tree.hpp

@@ -15,19 +15,19 @@ namespace duckdb {
 // Builds a merge sort tree that uses integer tokens for the comparison values instead of the sort keys.
 class WindowTokenTree : public WindowMergeSortTree {
 public:
-	WindowTokenTree(ClientContext &context, const vector<BoundOrderByNode> &orders, const vector<column_t> &sort_idx,
+	WindowTokenTree(ClientContext &context, const vector<BoundOrderByNode> &orders, const vector<column_t> &order_idx,
 	                const idx_t count, bool unique = false)
-	    : WindowMergeSortTree(context, orders, sort_idx, count, unique) {
+	    : WindowMergeSortTree(context, orders, order_idx, count, unique) {
 	}
-	WindowTokenTree(ClientContext &context, const BoundOrderModifier &order_bys, const vector<column_t> &sort_idx,
+	WindowTokenTree(ClientContext &context, const BoundOrderModifier &order_bys, const vector<column_t> &order_idx,
 	                const idx_t count, bool unique = false)
-	    : WindowTokenTree(context, order_bys.orders, sort_idx, count, unique) {
+	    : WindowTokenTree(context, order_bys.orders, order_idx, count, unique) {
 	}
 
-	unique_ptr<WindowAggregatorState> GetLocalState() override;
+	unique_ptr<LocalSinkState> GetLocalState(ExecutionContext &context) override;
 
 	//! Thread-safe post-sort cleanup
-	void CleanupSort() override;
+	void Finished() override;
 
 	//! Find the rank of the row within the range
 	idx_t Rank(const idx_t lower, const idx_t upper, const idx_t row_idx) const;