duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -1,63 +1,69 @@
 #include "duckdb/execution/window_segment_tree.hpp"
 
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+
+#include <utility>
 
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
-// WindowAggregateState
+// WindowAggregator
 //===--------------------------------------------------------------------===//
-
-WindowAggregateState::WindowAggregateState(AggregateObject aggr, const LogicalType &result_type_p)
-    : aggr(std::move(aggr)), result_type(result_type_p), state(aggr.function.state_size()),
-      statev(Value::POINTER(CastPointerToValue(state.data()))),
-      statep(Value::POINTER(CastPointerToValue(state.data()))) {
-	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
+WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) {
 }
 
-WindowAggregateState::~WindowAggregateState() {
+WindowAggregator::WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count_p)
+    : aggr(std::move(aggr)), result_type(result_type_p), partition_count(partition_count_p),
+      state_size(aggr.function.state_size()), filter_pos(0) {
 }
 
-void WindowAggregateState::AggregateInit() {
-	aggr.function.initialize(state.data());
+WindowAggregator::~WindowAggregator() {
 }
 
-void WindowAggregateState::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-	aggr.function.finalize(statev, aggr_input_data, result, 1, rid);
-
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
+void WindowAggregator::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
+	if (!inputs.ColumnCount() && payload_chunk.ColumnCount()) {
+		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
+	}
+	if (inputs.ColumnCount()) {
+		inputs.Append(payload_chunk, true);
+	}
+	if (filter_sel) {
+		//	Lazy instantiation
+		if (!filter_mask.IsMaskSet()) {
+			// 	Start with all invalid and set the ones that pass
+			filter_bits.resize(ValidityMask::ValidityMaskSize(partition_count), 0);
+			filter_mask.Initialize(filter_bits.data());
+		}
+		for (idx_t f = 0; f < filtered; ++f) {
+			filter_mask.SetValid(filter_pos + filter_sel->get_index(f));
+		}
+		filter_pos += payload_chunk.size();
 	}
 }
 
-void WindowAggregateState::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
-}
-
-void WindowAggregateState::Finalize() {
-}
-
-void WindowAggregateState::Compute(Vector &result, idx_t rid, idx_t start, idx_t end) {
+void WindowAggregator::Finalize() {
 }
 
 //===--------------------------------------------------------------------===//
 // WindowConstantAggregate
 //===--------------------------------------------------------------------===//
+WindowConstantAggregator::WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type,
+                                                   const ValidityMask &partition_mask, const idx_t count)
+    : WindowAggregator(std::move(aggr), result_type, count), partition(0), row(0), state(state_size),
+      statep(Value::POINTER(CastPointerToValue(state.data()))),
+      statef(Value::POINTER(CastPointerToValue(state.data()))) {
 
-WindowConstantAggregate::WindowConstantAggregate(AggregateObject aggr, const LogicalType &result_type,
-                                                 const ValidityMask &partition_mask, const idx_t count)
-    : WindowAggregateState(std::move(aggr), result_type), partition(0), row(0) {
+	statef.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 
 	// Locate the partition boundaries
-	idx_t start = 0;
 	if (partition_mask.AllValid()) {
 		partition_offsets.emplace_back(0);
 	} else {
 		idx_t entry_idx;
 		idx_t shift;
-		while (start < count) {
+		for (idx_t start = 0; start < count;) {
 			partition_mask.GetEntryIndex(start, entry_idx, shift);
 
 			//	If start is aligned with the start of a block,
@@ -81,11 +87,27 @@ WindowConstantAggregate::WindowConstantAggregate(AggregateObject aggr, const Log
 	results = make_uniq<Vector>(result_type, partition_offsets.size());
 	partition_offsets.emplace_back(count);
 
+	//	Create an aggregate state for intermediate aggregates
+	gstate = make_uniq<WindowAggregatorState>();
+
 	//	Start the first aggregate
 	AggregateInit();
 }
 
-void WindowConstantAggregate::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
+void WindowConstantAggregator::AggregateInit() {
+	aggr.function.initialize(state.data());
+}
+
+void WindowConstantAggregator::AggegateFinal(Vector &result, idx_t rid) {
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
+	aggr.function.finalize(statef, aggr_input_data, result, 1, rid);
+
+	if (aggr.function.destructor) {
+		aggr.function.destructor(statef, aggr_input_data, 1);
+	}
+}
+
+void WindowConstantAggregator::Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) {
 	const auto chunk_begin = row;
 	const auto chunk_end = chunk_begin + payload_chunk.size();
 
@@ -93,7 +115,7 @@ void WindowConstantAggregate::Sink(DataChunk &payload_chunk, SelectionVector *fi
 		inputs.Initialize(Allocator::DefaultAllocator(), payload_chunk.GetTypes());
 	}
 
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
 	idx_t begin = 0;
 	idx_t filter_idx = 0;
 	auto partition_end = partition_offsets[partition + 1];
@@ -158,50 +180,142 @@ void WindowConstantAggregate::Sink(DataChunk &payload_chunk, SelectionVector *fi
 	}
 }
 
-void WindowConstantAggregate::Finalize() {
+void WindowConstantAggregator::Finalize() {
 	AggegateFinal(*results, partition++);
+}
+
+class WindowConstantAggregatorState : public WindowAggregatorState {
+public:
+	WindowConstantAggregatorState() : partition(0) {
+		matches.Initialize();
+	}
+	~WindowConstantAggregatorState() override {
+	}
 
-	partition = 0;
-	row = 0;
+public:
+	//! The current result partition being read
+	idx_t partition;
+	//! Shared SV for evaluation
+	SelectionVector matches;
+};
+
+unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetLocalState() const {
+	return make_uniq<WindowConstantAggregatorState>();
+}
+
+void WindowConstantAggregator::Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends,
+                                        Vector &target, idx_t count) const {
+	//	Chunk up the constants and copy them one at a time
+	auto &lcstate = lstate.Cast<WindowConstantAggregatorState>();
+	idx_t matched = 0;
+	idx_t target_offset = 0;
+	for (idx_t i = 0; i < count; ++i) {
+		const auto begin = begins[i];
+		//	Find the partition containing [begin, end)
+		while (partition_offsets[lcstate.partition + 1] <= begin) {
+			//	Flush the previous partition's data
+			if (matched) {
+				VectorOperations::Copy(*results, target, lcstate.matches, matched, 0, target_offset);
+				target_offset += matched;
+				matched = 0;
+			}
+			++lcstate.partition;
+		}
+
+		lcstate.matches.set_index(matched++, lcstate.partition);
+	}
+
+	//	Flush the last partition
+	if (matched) {
+		VectorOperations::Copy(*results, target, lcstate.matches, matched, 0, target_offset);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// WindowCustomAggregator
+//===--------------------------------------------------------------------===//
+WindowCustomAggregator::WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type, idx_t count)
+    : WindowAggregator(std::move(aggr), result_type, count) {
+}
+
+WindowCustomAggregator::~WindowCustomAggregator() {
 }
 
-void WindowConstantAggregate::Compute(Vector &target, idx_t rid, idx_t start, idx_t end) {
-	//	Find the partition containing [start, end)
-	while (start < partition_offsets[partition] || partition_offsets[partition + 1] <= start) {
-		++partition;
+class WindowCustomAggregatorState : public WindowAggregatorState {
+public:
+	explicit WindowCustomAggregatorState(const AggregateObject &aggr, DataChunk &inputs);
+	~WindowCustomAggregatorState() override;
+
+public:
+	//! The aggregate function
+	const AggregateObject &aggr;
+	//! The aggregate function
+	DataChunk &inputs;
+	//! Data pointer that contains a single state, shared by all the custom evaluators
+	vector<data_t> state;
+	//! Reused result state container for the window functions
+	Vector statef;
+	//! The frame boundaries, used for the window functions
+	FrameBounds frame;
+};
+
+WindowCustomAggregatorState::WindowCustomAggregatorState(const AggregateObject &aggr, DataChunk &inputs)
+    : aggr(aggr), inputs(inputs), state(aggr.function.state_size()),
+      statef(Value::POINTER(CastPointerToValue(state.data()))), frame(0, 0) {
+	// if we have a frame-by-frame method, share the single state
+	aggr.function.initialize(state.data());
+}
+
+WindowCustomAggregatorState::~WindowCustomAggregatorState() {
+	if (aggr.function.destructor) {
+		AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+		aggr.function.destructor(statef, aggr_input_data, 1);
 	}
-	D_ASSERT(partition_offsets[partition] <= start);
-	D_ASSERT(partition + 1 < partition_offsets.size());
-	D_ASSERT(end <= partition_offsets[partition + 1]);
+}
+
+unique_ptr<WindowAggregatorState> WindowCustomAggregator::GetLocalState() const {
+	return make_uniq<WindowCustomAggregatorState>(aggr, const_cast<DataChunk &>(inputs));
+}
 
-	// Copy the value
-	VectorOperations::Copy(*results, target, partition + 1, partition, rid);
+void WindowCustomAggregator::Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends,
+                                      Vector &result, idx_t count) const {
+	//	TODO: window should take a const Vector*
+	auto &lcstate = lstate.Cast<WindowCustomAggregatorState>();
+	auto &frame = lcstate.frame;
+	auto params = lcstate.inputs.data.data();
+	auto &rmask = FlatVector::Validity(result);
+	for (idx_t i = 0; i < count; ++i) {
+		const auto begin = begins[i];
+		const auto end = ends[i];
+		if (begin >= end) {
+			rmask.SetInvalid(i);
+			continue;
+		}
+
+		// Frame boundaries
+		auto prev = frame;
+		frame = FrameBounds(begin, end);
+
+		// Extract the range
+		AggregateInputData aggr_input_data(aggr.GetFunctionData(), lstate.allocator);
+		aggr.function.window(params, filter_mask, aggr_input_data, inputs.ColumnCount(), lcstate.state.data(), frame,
+		                     prev, result, i, 0);
+	}
 }
 
 //===--------------------------------------------------------------------===//
 // WindowSegmentTree
 //===--------------------------------------------------------------------===//
-WindowSegmentTree::WindowSegmentTree(AggregateObject aggr_p, const LogicalType &result_type_p, DataChunk *input,
-                                     const ValidityMask &filter_mask_p, WindowAggregationMode mode_p)
-    : aggr(std::move(aggr_p)), result_type(result_type_p), state(aggr.function.state_size()),
-      statep(Value::POINTER(CastPointerToValue(state.data()))), frame(0, 0),
-      statev(Value::POINTER(CastPointerToValue(state.data()))), internal_nodes(0), input_ref(input),
-      filter_mask(filter_mask_p), mode(mode_p) {
-	statep.Flatten(input->size());
-	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
-
-	if (input_ref && input_ref->ColumnCount() > 0) {
-		filter_sel.Initialize(input->size());
-		inputs.Initialize(Allocator::DefaultAllocator(), input_ref->GetTypes());
-		// if we have a frame-by-frame method, share the single state
-		if (aggr.function.window && UseWindowAPI()) {
-			AggregateInit();
-			inputs.Reference(*input_ref);
-		} else {
-			inputs.SetCapacity(*input_ref);
-			if (aggr.function.combine && UseCombineAPI()) {
-				ConstructTree();
-			}
+WindowSegmentTree::WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, idx_t count,
+                                     WindowAggregationMode mode_p)
+    : WindowAggregator(std::move(aggr), result_type, count), internal_nodes(0), mode(mode_p) {
+}
+
+void WindowSegmentTree::Finalize() {
+	gstate = GetLocalState();
+	if (inputs.ColumnCount() > 0) {
+		if (aggr.function.combine && UseCombineAPI()) {
+			ConstructTree();
 		}
 	}
 }
@@ -211,13 +325,13 @@ WindowSegmentTree::~WindowSegmentTree() {
 		// nothing to destroy
 		return;
 	}
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), gstate->allocator);
 	// call the destructor for all the intermediate states
 	data_ptr_t address_data[STANDARD_VECTOR_SIZE];
 	Vector addresses(LogicalType::POINTER, data_ptr_cast(address_data));
 	idx_t count = 0;
 	for (idx_t i = 0; i < internal_nodes; i++) {
-		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state.size());
+		address_data[count++] = data_ptr_t(levels_flat_native.get() + i * state_size);
 		if (count == STANDARD_VECTOR_SIZE) {
 			aggr.function.destructor(addresses, aggr_input_data, count);
 			count = 0;
@@ -226,92 +340,170 @@ WindowSegmentTree::~WindowSegmentTree() {
 	if (count > 0) {
 		aggr.function.destructor(addresses, aggr_input_data, count);
 	}
+}
+
+class WindowSegmentTreeState : public WindowAggregatorState {
+public:
+	WindowSegmentTreeState(const AggregateObject &aggr, DataChunk &inputs, const ValidityMask &filter_mask);
+	~WindowSegmentTreeState() override;
+
+	void FlushStates(bool combining);
+	void ExtractFrame(idx_t begin, idx_t end, data_ptr_t current_state);
+	void WindowSegmentValue(const WindowSegmentTree &tree, idx_t l_idx, idx_t begin, idx_t end,
+	                        data_ptr_t current_state);
+	void Finalize(Vector &result, idx_t count);
+
+public:
+	//! The aggregate function
+	const AggregateObject &aggr;
+	//! The aggregate function
+	DataChunk &inputs;
+	//! The filtered rows in inputs
+	const ValidityMask &filter_mask;
+	//! The size of a single aggregate state
+	const idx_t state_size;
+	//! Data pointer that contains a single state, used for intermediate window segment aggregation
+	vector<data_t> state;
+	//! Input data chunk, used for leaf segment aggregation
+	DataChunk leaves;
+	//! The filtered rows in inputs.
+	SelectionVector filter_sel;
+	//! A vector of pointers to "state", used for intermediate window segment aggregation
+	Vector statep;
+	//! Reused state pointers for combining segment tree levels
+	Vector statel;
+	//! Reused result state container for the window functions
+	Vector statef;
+	//! Count of buffered values
+	idx_t flush_count;
+};
+
+WindowSegmentTreeState::WindowSegmentTreeState(const AggregateObject &aggr, DataChunk &inputs,
+                                               const ValidityMask &filter_mask)
+    : aggr(aggr), inputs(inputs), filter_mask(filter_mask), state_size(aggr.function.state_size()),
+      state(state_size * STANDARD_VECTOR_SIZE), statep(LogicalType::POINTER), statel(LogicalType::POINTER),
+      statef(LogicalType::POINTER), flush_count(0) {
+	if (inputs.ColumnCount() > 0) {
+		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
+		filter_sel.Initialize();
+	}
 
-	if (aggr.function.window && UseWindowAPI()) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
+	//	Build the finalise vector that just points to the result states
+	data_ptr_t state_ptr = state.data();
+	D_ASSERT(statef.GetVectorType() == VectorType::FLAT_VECTOR);
+	statef.SetVectorType(VectorType::CONSTANT_VECTOR);
+	statef.Flatten(STANDARD_VECTOR_SIZE);
+	auto fdata = FlatVector::GetData<data_ptr_t>(statef);
+	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; ++i) {
+		fdata[i] = state_ptr;
+		state_ptr += state_size;
 	}
 }
 
-void WindowSegmentTree::AggregateInit() {
-	aggr.function.initialize(state.data());
+WindowSegmentTreeState::~WindowSegmentTreeState() {
 }
 
-void WindowSegmentTree::AggegateFinal(Vector &result, idx_t rid) {
-	AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-	aggr.function.finalize(statev, aggr_input_data, result, 1, rid);
+unique_ptr<WindowAggregatorState> WindowSegmentTree::GetLocalState() const {
+	return make_uniq<WindowSegmentTreeState>(aggr, const_cast<DataChunk &>(inputs), filter_mask);
+}
 
-	if (aggr.function.destructor) {
-		aggr.function.destructor(statev, aggr_input_data, 1);
+void WindowSegmentTreeState::FlushStates(bool combining) {
+	if (!flush_count) {
+		return;
 	}
-}
 
-void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
-	const auto size = end - begin;
-
-	auto &chunk = *input_ref;
-	const auto input_count = input_ref->ColumnCount();
-	inputs.SetCardinality(size);
-	for (idx_t i = 0; i < input_count; ++i) {
-		auto &v = inputs.data[i];
-		auto &vec = chunk.data[i];
-		v.Slice(vec, begin, end);
-		v.Verify(size);
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	if (combining) {
+		statel.Verify(flush_count);
+		aggr.function.combine(statel, statep, aggr_input_data, flush_count);
+	} else {
+		leaves.Reference(inputs);
+		leaves.Slice(filter_sel, flush_count);
+		aggr.function.update(&leaves.data[0], aggr_input_data, leaves.ColumnCount(), statep, flush_count);
 	}
 
-	// Slice to any filtered rows
-	if (!filter_mask.AllValid()) {
-		idx_t filtered = 0;
+	flush_count = 0;
+}
+
+void WindowSegmentTreeState::ExtractFrame(idx_t begin, idx_t end, data_ptr_t state_ptr) {
+	const auto count = end - begin;
+
+	//	If we are not filtering,
+	//	just update the shared dictionary selection to the range
+	//	Otherwise set it to the input rows that pass the filter
+	auto states = FlatVector::GetData<data_ptr_t>(statep);
+	if (filter_mask.AllValid()) {
+		for (idx_t i = 0; i < count; ++i) {
+			states[flush_count] = state_ptr;
+			filter_sel.set_index(flush_count++, begin + i);
+			if (flush_count >= STANDARD_VECTOR_SIZE) {
+				FlushStates(false);
+			}
+		}
+	} else {
 		for (idx_t i = begin; i < end; ++i) {
 			if (filter_mask.RowIsValid(i)) {
-				filter_sel.set_index(filtered++, i - begin);
+				states[flush_count] = state_ptr;
+				filter_sel.set_index(flush_count++, i);
+				if (flush_count >= STANDARD_VECTOR_SIZE) {
+					FlushStates(false);
+				}
 			}
 		}
-		if (filtered != inputs.size()) {
-			inputs.Slice(filter_sel, filtered);
-		}
 	}
 }
 
-void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
+void WindowSegmentTreeState::WindowSegmentValue(const WindowSegmentTree &tree, idx_t l_idx, idx_t begin, idx_t end,
+                                                data_ptr_t state_ptr) {
 	D_ASSERT(begin <= end);
 	if (begin == end || inputs.ColumnCount() == 0) {
 		return;
 	}
 
 	const auto count = end - begin;
-	Vector s(statep, 0, count);
 	if (l_idx == 0) {
-		ExtractFrame(begin, end);
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		D_ASSERT(!inputs.data.empty());
-		aggr.function.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
+		ExtractFrame(begin, end, state_ptr);
 	} else {
 		// find out where the states begin
-		data_ptr_t begin_ptr = levels_flat_native.get() + state.size() * (begin + levels_flat_start[l_idx - 1]);
+		auto begin_ptr = tree.levels_flat_native.get() + state_size * (begin + tree.levels_flat_start[l_idx - 1]);
 		// set up a vector of pointers that point towards the set of states
-		Vector v(LogicalType::POINTER, count);
-		auto pdata = FlatVector::GetData<data_ptr_t>(v);
+		auto ldata = FlatVector::GetData<data_ptr_t>(statel);
+		auto pdata = FlatVector::GetData<data_ptr_t>(statep);
 		for (idx_t i = 0; i < count; i++) {
-			pdata[i] = begin_ptr + i * state.size();
+			pdata[flush_count] = state_ptr;
+			ldata[flush_count++] = begin_ptr;
+			begin_ptr += state_size;
+			if (flush_count >= STANDARD_VECTOR_SIZE) {
+				FlushStates(true);
+			}
 		}
-		v.Verify(count);
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		aggr.function.combine(v, s, aggr_input_data, count);
+	}
+}
+void WindowSegmentTreeState::Finalize(Vector &result, idx_t count) {
+	//	Finalise the result aggregates
+	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
+	aggr.function.finalize(statef, aggr_input_data, result, count, 0);
+
+	//	Destruct the result aggregates
+	if (aggr.function.destructor) {
+		aggr.function.destructor(statef, aggr_input_data, count);
 	}
 }
 
 void WindowSegmentTree::ConstructTree() {
-	D_ASSERT(input_ref);
 	D_ASSERT(inputs.ColumnCount() > 0);
 
+	//	Use a temporary scan state to build the tree
+	auto &gtstate = gstate->Cast<WindowSegmentTreeState>();
+
 	// compute space required to store internal nodes of segment tree
 	internal_nodes = 0;
-	idx_t level_nodes = input_ref->size();
+	idx_t level_nodes = inputs.size();
 	do {
 		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
 		internal_nodes += level_nodes;
 	} while (level_nodes > 1);
-	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state.size());
+	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state_size);
 	levels_flat_start.push_back(0);
 
 	idx_t levels_flat_offset = 0;
@@ -319,14 +511,14 @@ void WindowSegmentTree::ConstructTree() {
 	// level 0 is data itself
 	idx_t level_size;
 	// iterate over the levels of the segment tree
-	while ((level_size = (level_current == 0 ? input_ref->size()
-	                                         : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
+	while ((level_size =
+	            (level_current == 0 ? inputs.size() : levels_flat_offset - levels_flat_start[level_current - 1])) > 1) {
 		for (idx_t pos = 0; pos < level_size; pos += TREE_FANOUT) {
 			// compute the aggregate for this entry in the segment tree
-			AggregateInit();
-			WindowSegmentValue(level_current, pos, MinValue(level_size, pos + TREE_FANOUT));
-
-			memcpy(levels_flat_native.get() + (levels_flat_offset * state.size()), state.data(), state.size());
+			data_ptr_t state_ptr = levels_flat_native.get() + (levels_flat_offset * state_size);
+			aggr.function.initialize(state_ptr);
+			gtstate.WindowSegmentValue(*this, level_current, pos, MinValue(level_size, pos + TREE_FANOUT), state_ptr);
+			gtstate.FlushStates(level_current > 0);
 
 			levels_flat_offset++;
 		}
@@ -341,52 +533,124 @@ void WindowSegmentTree::ConstructTree() {
 	}
 }
 
-void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t end) {
-	D_ASSERT(input_ref);
+void WindowSegmentTree::Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
+                                 idx_t count) const {
+	auto &ltstate = lstate.Cast<WindowSegmentTreeState>();
+	const auto cant_combine = (!aggr.function.combine || !UseCombineAPI());
+	auto fdata = FlatVector::GetData<data_ptr_t>(ltstate.statef);
+
+	//	First pass: aggregate the segment tree nodes
+	//	Share adjacent identical states
+	//  We do this first because we want to share only tree aggregations
+	idx_t prev_begin = 1;
+	idx_t prev_end = 0;
+	auto ldata = FlatVector::GetData<data_ptr_t>(ltstate.statel);
+	auto pdata = FlatVector::GetData<data_ptr_t>(ltstate.statep);
+	data_ptr_t prev_state = nullptr;
+	for (idx_t rid = 0; rid < count; ++rid) {
+		auto state_ptr = fdata[rid];
+		aggr.function.initialize(state_ptr);
+
+		if (cant_combine) {
+			// Make sure we initialise all states
+			continue;
+		}
 
-	// If we have a window function, use that
-	if (aggr.function.window && UseWindowAPI()) {
-		// Frame boundaries
-		auto prev = frame;
-		frame = FrameBounds(begin, end);
+		auto begin = begins[rid];
+		auto end = ends[rid];
+		if (begin >= end) {
+			continue;
+		}
 
-		// Extract the range
-		AggregateInputData aggr_input_data(aggr.GetFunctionData(), Allocator::DefaultAllocator());
-		aggr.function.window(input_ref->data.data(), filter_mask, aggr_input_data, inputs.ColumnCount(), state.data(),
-		                     frame, prev, result, rid, 0);
-		return;
-	}
+		//	Skip level 0
+		idx_t l_idx = 0;
+		for (; l_idx < levels_flat_start.size() + 1; l_idx++) {
+			idx_t parent_begin = begin / TREE_FANOUT;
+			idx_t parent_end = end / TREE_FANOUT;
+			if (prev_state && l_idx == 1 && begin == prev_begin && end == prev_end) {
+				//	Just combine the previous top level result
+				ldata[ltstate.flush_count] = prev_state;
+				pdata[ltstate.flush_count] = state_ptr;
+				if (++ltstate.flush_count >= STANDARD_VECTOR_SIZE) {
+					ltstate.FlushStates(true);
+				}
+				break;
+			}
 
-	AggregateInit();
+			if (l_idx == 1) {
+				prev_state = state_ptr;
+				prev_begin = begin;
+				prev_end = end;
+			}
 
-	// Aggregate everything at once if we can't combine states
-	if (!aggr.function.combine || !UseCombineAPI()) {
-		WindowSegmentValue(0, begin, end);
-		AggegateFinal(result, rid);
-		return;
+			if (parent_begin == parent_end) {
+				if (l_idx) {
+					ltstate.WindowSegmentValue(*this, l_idx, begin, end, state_ptr);
+				}
+				break;
+			}
+			idx_t group_begin = parent_begin * TREE_FANOUT;
+			if (begin != group_begin) {
+				if (l_idx) {
+					ltstate.WindowSegmentValue(*this, l_idx, begin, group_begin + TREE_FANOUT, state_ptr);
+				}
+				parent_begin++;
+			}
+			idx_t group_end = parent_end * TREE_FANOUT;
+			if (end != group_end) {
+				if (l_idx) {
+					ltstate.WindowSegmentValue(*this, l_idx, group_end, end, state_ptr);
+				}
+			}
+			begin = parent_begin;
+			end = parent_end;
+		}
 	}
+	ltstate.FlushStates(true);
+
+	//	Second pass: aggregate the ragged leaves
+	//	(or everything if we can't combine)
+	for (idx_t rid = 0; rid < count; ++rid) {
+		auto state_ptr = fdata[rid];
 
-	for (idx_t l_idx = 0; l_idx < levels_flat_start.size() + 1; l_idx++) {
+		const auto begin = begins[rid];
+		const auto end = ends[rid];
+		if (begin >= end) {
+			continue;
+		}
+
+		// Aggregate everything at once if we can't combine states
 		idx_t parent_begin = begin / TREE_FANOUT;
 		idx_t parent_end = end / TREE_FANOUT;
-		if (parent_begin == parent_end) {
-			WindowSegmentValue(l_idx, begin, end);
-			break;
+		if (parent_begin == parent_end || cant_combine) {
+			ltstate.WindowSegmentValue(*this, 0, begin, end, state_ptr);
+			continue;
 		}
+
 		idx_t group_begin = parent_begin * TREE_FANOUT;
 		if (begin != group_begin) {
-			WindowSegmentValue(l_idx, begin, group_begin + TREE_FANOUT);
+			ltstate.WindowSegmentValue(*this, 0, begin, group_begin + TREE_FANOUT, state_ptr);
 			parent_begin++;
 		}
 		idx_t group_end = parent_end * TREE_FANOUT;
 		if (end != group_end) {
-			WindowSegmentValue(l_idx, group_end, end);
+			ltstate.WindowSegmentValue(*this, 0, group_end, end, state_ptr);
 		}
-		begin = parent_begin;
-		end = parent_end;
 	}
+	ltstate.FlushStates(false);
+
+	ltstate.Finalize(result, count);
 
-	AggegateFinal(result, rid);
+	//	Set the validity mask on  the invalid rows
+	auto &rmask = FlatVector::Validity(result);
+	for (idx_t rid = 0; rid < count; ++rid) {
+		const auto begin = begins[rid];
+		const auto end = ends[rid];
+
+		if (begin >= end) {
+			rmask.SetInvalid(rid);
+		}
+	}
 }
 
 } // namespace duckdb