duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -69,13 +69,27 @@ unique_ptr<GroupedAggregateHashTable> RadixPartitionedHashTable::CreateHT(Client
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
+enum class AggregatePartitionState : uint8_t {
+	//! Can be finalized
+	READY_TO_FINALIZE = 0,
+	//! Finalize is in progress
+	FINALIZE_IN_PROGRESS = 1,
+	//! Finalized, ready to scan
+	READY_TO_SCAN = 2
+};
+
 struct AggregatePartition {
 	explicit AggregatePartition(unique_ptr<TupleDataCollection> data_p)
-	    : data(std::move(data_p)), progress(0), finalized(false) {
+	    : state(AggregatePartitionState::READY_TO_FINALIZE), data(std::move(data_p)), progress(0) {
 	}
+
+	mutex lock;
+	AggregatePartitionState state;
+
 	unique_ptr<TupleDataCollection> data;
 	atomic<double> progress;
-	atomic<bool> finalized;
+
+	vector<InterruptState> blocked_tasks;
 };
 
 class RadixHTGlobalSinkState;
@@ -165,9 +179,7 @@ public:
 
 	//! Partitions that are finalized during GetData
 	vector<unique_ptr<AggregatePartition>> partitions;
-
-	//! For synchronizing finalize tasks
-	atomic<idx_t> finalize_idx;
+	//! For keeping track of progress
 	atomic<idx_t> finalize_done;
 
 	//! Pin properties when scanning
@@ -176,16 +188,13 @@ public:
 	idx_t count_before_combining;
 	//! Maximum partition size if all unique
 	idx_t max_partition_size;
-
-	vector<InterruptState> blocked_tasks;
 };
 
 RadixHTGlobalSinkState::RadixHTGlobalSinkState(ClientContext &context_p, const RadixPartitionedHashTable &radix_ht_p)
     : context(context_p), temporary_memory_state(TemporaryMemoryManager::Get(context).Register(context)),
       radix_ht(radix_ht_p), config(context, *this), finalized(false), external(false), active_threads(0),
-      any_combined(false), finalize_idx(0), finalize_done(0),
-      scan_pin_properties(TupleDataPinProperties::DESTROY_AFTER_DONE), count_before_combining(0),
-      max_partition_size(0) {
+      any_combined(false), finalize_done(0), scan_pin_properties(TupleDataPinProperties::DESTROY_AFTER_DONE),
+      count_before_combining(0), max_partition_size(0) {
 
 	auto tuples_per_block = Storage::BLOCK_ALLOC_SIZE / radix_ht.GetLayout().GetRowWidth();
 	idx_t ht_count = config.sink_capacity / GroupedAggregateHashTable::LOAD_FACTOR;
@@ -516,8 +525,9 @@ void RadixPartitionedHashTable::Finalize(ClientContext &context, GlobalSinkState
 
 			gstate.partitions.emplace_back(make_uniq<AggregatePartition>(std::move(partition)));
 			if (single_ht) {
-				gstate.finalize_idx++;
-				gstate.partitions.back()->finalized = true;
+				gstate.finalize_done++;
+				gstate.partitions.back()->progress = 1;
+				gstate.partitions.back()->state = AggregatePartitionState::READY_TO_SCAN;
 			}
 		}
 	} else {
@@ -566,7 +576,8 @@ public:
 	RadixHTGlobalSourceState(ClientContext &context, const RadixPartitionedHashTable &radix_ht);
 
 	//! Assigns a task to a local source state
-	bool AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate);
+	SourceResultType AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate,
+	                            InterruptState &interrupt_state);
 
 public:
 	//! The client context
@@ -577,10 +588,10 @@ public:
 	//! Column ids for scanning
 	vector<column_t> column_ids;
 
-	//! For synchronizing scan tasks
+	//! For synchronizing tasks
 	mutex lock;
-	idx_t scan_idx;
-	atomic<idx_t> scan_done;
+	idx_t task_idx;
+	atomic<idx_t> task_done;
 };
 
 enum class RadixHTScanStatus : uint8_t { INIT, IN_PROGRESS, DONE };
@@ -629,61 +640,44 @@ unique_ptr<LocalSourceState> RadixPartitionedHashTable::GetLocalSourceState(Exec
 }
 
 RadixHTGlobalSourceState::RadixHTGlobalSourceState(ClientContext &context_p, const RadixPartitionedHashTable &radix_ht)
-    : context(context_p), finished(false), scan_idx(0), scan_done(0) {
+    : context(context_p), finished(false), task_idx(0), task_done(0) {
 	for (column_t column_id = 0; column_id < radix_ht.group_types.size(); column_id++) {
 		column_ids.push_back(column_id);
 	}
 }
 
-bool RadixHTGlobalSourceState::AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate) {
-	D_ASSERT(lstate.scan_status != RadixHTScanStatus::IN_PROGRESS);
-
-	const auto n_partitions = sink.partitions.size();
+SourceResultType RadixHTGlobalSourceState::AssignTask(RadixHTGlobalSinkState &sink, RadixHTLocalSourceState &lstate,
+                                                      InterruptState &interrupt_state) {
+	// First, try to get a partition index
+	lock_guard<mutex> gstate_guard(lock);
 	if (finished) {
-		return false;
+		return SourceResultType::FINISHED;
 	}
-
-	// We first try to assign a Scan task, then a Finalize task if that didn't work
-	bool scan_assigned = false;
-	if (scan_idx < n_partitions && sink.partitions[scan_idx]->finalized) {
-		lstate.task_idx = scan_idx++;
-		scan_assigned = true;
-		if (scan_idx == n_partitions) {
-			// We will never be able to assign another task, unblock blocked tasks
-			lock_guard<mutex> sink_guard(sink.lock);
-			if (!sink.blocked_tasks.empty()) {
-				for (auto &state : sink.blocked_tasks) {
-					state.Callback();
-				}
-				sink.blocked_tasks.clear();
-			}
-		}
+	if (task_idx == sink.partitions.size()) {
+		return SourceResultType::FINISHED;
 	}
+	lstate.task_idx = task_idx++;
 
-	if (scan_assigned) {
-		// We successfully assigned a Scan task
-		D_ASSERT(lstate.task_idx < n_partitions && sink.partitions[lstate.task_idx]->finalized);
+	// We got a partition index
+	auto &partition = *sink.partitions[lstate.task_idx];
+	auto partition_lock = unique_lock<mutex>(partition.lock);
+	switch (partition.state) {
+	case AggregatePartitionState::READY_TO_FINALIZE:
+		partition.state = AggregatePartitionState::FINALIZE_IN_PROGRESS;
+		lstate.task = RadixHTSourceTaskType::FINALIZE;
+		return SourceResultType::HAVE_MORE_OUTPUT;
+	case AggregatePartitionState::FINALIZE_IN_PROGRESS:
 		lstate.task = RadixHTSourceTaskType::SCAN;
 		lstate.scan_status = RadixHTScanStatus::INIT;
-		return true;
-	}
-
-	// We didn't assign a Scan task
-	if (sink.finalize_idx >= n_partitions) {
-		lstate.ht.reset();
-		return false; // No finalize tasks left
-	}
-
-	// We can just increment the atomic here, much simpler than assigning the scan task
-	lstate.task_idx = sink.finalize_idx++;
-	if (lstate.task_idx < n_partitions) {
-		// We successfully assigned a Finalize task
-		lstate.task = RadixHTSourceTaskType::FINALIZE;
-		return true;
+		partition.blocked_tasks.push_back(interrupt_state);
+		return SourceResultType::BLOCKED;
+	case AggregatePartitionState::READY_TO_SCAN:
+		lstate.task = RadixHTSourceTaskType::SCAN;
+		lstate.scan_status = RadixHTScanStatus::INIT;
+		return SourceResultType::HAVE_MORE_OUTPUT;
+	default:
+		throw InternalException("Unexpected AggregatePartitionState in RadixHTLocalSourceState::Finalize!");
 	}
-
-	// We didn't manage to assign a Finalize task because there are none left
-	return false;
 }
 
 RadixHTLocalSourceState::RadixHTLocalSourceState(ExecutionContext &context, const RadixPartitionedHashTable &radix_ht)
@@ -699,6 +693,7 @@ RadixHTLocalSourceState::RadixHTLocalSourceState(ExecutionContext &context, cons
 
 void RadixHTLocalSourceState::ExecuteTask(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate,
                                           DataChunk &chunk) {
+	D_ASSERT(task != RadixHTSourceTaskType::NO_TASK);
 	switch (task) {
 	case RadixHTSourceTaskType::FINALIZE:
 		Finalize(sink, gstate);
@@ -714,12 +709,7 @@ void RadixHTLocalSourceState::ExecuteTask(RadixHTGlobalSinkState &sink, RadixHTG
 void RadixHTLocalSourceState::Finalize(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate) {
 	D_ASSERT(task == RadixHTSourceTaskType::FINALIZE);
 	D_ASSERT(scan_status != RadixHTScanStatus::IN_PROGRESS);
-
 	auto &partition = *sink.partitions[task_idx];
-	if (partition.data->Count() == 0) {
-		partition.finalized = true;
-		return;
-	}
 
 	if (!ht) {
 		// This capacity would always be sufficient for all data
@@ -730,7 +720,7 @@ void RadixHTLocalSourceState::Finalize(RadixHTGlobalSinkState &sink, RadixHTGlob
 		const idx_t memory_limit = BufferManager::GetBufferManager(gstate.context).GetMaxMemory();
 		const idx_t thread_limit = 0.6 * memory_limit / n_threads;
 
-		const idx_t size_per_entry = partition.data->SizeInBytes() / partition.data->Count() +
+		const idx_t size_per_entry = partition.data->SizeInBytes() / MaxValue<idx_t>(partition.data->Count(), 1) +
 		                             idx_t(GroupedAggregateHashTable::LOAD_FACTOR * sizeof(aggr_ht_entry_t));
 		const auto capacity_limit = NextPowerOfTwo(thread_limit / size_per_entry);
 
@@ -745,32 +735,34 @@ void RadixHTLocalSourceState::Finalize(RadixHTGlobalSinkState &sink, RadixHTGlob
 	// Now combine the uncombined data using this thread's HT
 	ht->Combine(*partition.data, &partition.progress);
 	ht->UnpinData();
+	partition.progress = 1;
 
 	// Move the combined data back to the partition
 	partition.data =
 	    make_uniq<TupleDataCollection>(BufferManager::GetBufferManager(gstate.context), sink.radix_ht.GetLayout());
 	partition.data->Combine(*ht->GetPartitionedData()->GetPartitions()[0]);
 
-	// Mark partition as ready to scan
-	lock_guard<mutex> glock(gstate.lock);
-	partition.finalized = true;
-
-	if (++sink.finalize_done == sink.partitions.size()) {
+	// Update thread-global state
+	lock_guard<mutex> global_guard(gstate.lock);
+	sink.stored_allocators.emplace_back(ht->GetAggregateAllocator());
+	const auto finalizes_done = ++sink.finalize_done;
+	D_ASSERT(finalizes_done <= sink.partitions.size());
+	if (finalizes_done == sink.partitions.size()) {
 		// All finalizes are done, set remaining size to 0
 		sink.temporary_memory_state->SetRemainingSize(sink.context, 0);
 	}
 
-	// Unblock blocked tasks so they can scan this partition
-	lock_guard<mutex> sink_guard(sink.lock);
-	if (!sink.blocked_tasks.empty()) {
-		for (auto &state : sink.blocked_tasks) {
-			state.Callback();
-		}
-		sink.blocked_tasks.clear();
+	// Update partition state
+	lock_guard<mutex> partition_guard(partition.lock);
+	partition.state = AggregatePartitionState::READY_TO_SCAN;
+	for (auto &blocked_task : partition.blocked_tasks) {
+		blocked_task.Callback();
 	}
+	partition.blocked_tasks.clear();
 
-	// Make sure this thread's aggregate allocator does not get lost
-	sink.stored_allocators.emplace_back(ht->GetAggregateAllocator());
+	// This thread will scan the partition
+	task = RadixHTSourceTaskType::SCAN;
+	scan_status = RadixHTScanStatus::INIT;
 }
 
 void RadixHTLocalSourceState::Scan(RadixHTGlobalSinkState &sink, RadixHTGlobalSourceState &gstate, DataChunk &chunk) {
@@ -778,36 +770,24 @@ void RadixHTLocalSourceState::Scan(RadixHTGlobalSinkState &sink, RadixHTGlobalSo
 	D_ASSERT(scan_status != RadixHTScanStatus::DONE);
 
 	auto &partition = *sink.partitions[task_idx];
-	D_ASSERT(partition.finalized);
+	D_ASSERT(partition.state == AggregatePartitionState::READY_TO_SCAN);
 	auto &data_collection = *partition.data;
 
-	if (data_collection.Count() == 0) {
-		scan_status = RadixHTScanStatus::DONE;
-		lock_guard<mutex> gstate_guard(gstate.lock);
-		if (++gstate.scan_done == sink.partitions.size()) {
-			gstate.finished = true;
-		}
-		return;
-	}
-
 	if (scan_status == RadixHTScanStatus::INIT) {
 		data_collection.InitializeScan(scan_state, gstate.column_ids, sink.scan_pin_properties);
 		scan_status = RadixHTScanStatus::IN_PROGRESS;
 	}
 
 	if (!data_collection.Scan(scan_state, scan_chunk)) {
-		scan_status = RadixHTScanStatus::DONE;
 		if (sink.scan_pin_properties == TupleDataPinProperties::DESTROY_AFTER_DONE) {
 			data_collection.Reset();
 		}
-		return;
-	}
-
-	if (data_collection.ScanComplete(scan_state)) {
+		scan_status = RadixHTScanStatus::DONE;
 		lock_guard<mutex> gstate_guard(gstate.lock);
-		if (++gstate.scan_done == sink.partitions.size()) {
+		if (++gstate.task_done == sink.partitions.size()) {
 			gstate.finished = true;
 		}
+		return;
 	}
 
 	RowOperationsState row_state(aggregate_allocator);
@@ -902,15 +882,10 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 
 	while (!gstate.finished && chunk.size() == 0) {
 		if (lstate.TaskFinished()) {
-			lock_guard<mutex> gstate_guard(gstate.lock);
-			if (!gstate.AssignTask(sink, lstate)) {
-				if (gstate.scan_idx < sink.partitions.size()) {
-					lock_guard<mutex> sink_guard(sink.lock);
-					sink.blocked_tasks.push_back(input.interrupt_state);
-					return SourceResultType::BLOCKED;
-				} else {
-					return SourceResultType::FINISHED;
-				}
+			const auto res = gstate.AssignTask(sink, lstate, input.interrupt_state);
+			if (res != SourceResultType::HAVE_MORE_OUTPUT) {
+				D_ASSERT(res == SourceResultType::FINISHED || res == SourceResultType::BLOCKED);
+				return res;
 			}
 		}
 		lstate.ExecuteTask(sink, gstate, chunk);
@@ -931,11 +906,11 @@ double RadixPartitionedHashTable::GetProgress(ClientContext &, GlobalSinkState &
 	// Get partition combine progress, weigh it 2x
 	double total_progress = 0;
 	for (auto &partition : sink.partitions) {
-		total_progress += partition->progress * 2.0;
+		total_progress += 2.0 * partition->progress;
 	}
 
 	// Get scan progress, weigh it 1x
-	total_progress += gstate.scan_done;
+	total_progress += 1.0 * gstate.task_done;
 
 	// Divide by 3x for the weights, and the number of partitions to get a value between 0 and 1 again
 	total_progress /= 3.0 * sink.partitions.size();

package/src/duckdb/src/execution/reservoir_sample.cpp

@@ -305,7 +305,7 @@ void BaseReservoirSampling::ReplaceElement(double with_weight) {
 		r2 = with_weight;
 	}
 	//! now we insert the new weight into the reservoir
-	reservoir_weights.push(std::make_pair(-r2, min_weighted_entry_index));
+	reservoir_weights.emplace(-r2, min_weighted_entry_index);
 	//! we update the min entry with the new min entry in the reservoir
 	SetNextEntry();
 }

package/src/duckdb/src/execution/window_executor.cpp

@@ -199,17 +199,34 @@ struct OperationCompare : public std::function<bool(T, T)> {
 
 template <typename T, typename OP, bool FROM>
 static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t order_begin, const idx_t order_end,
-                                 WindowInputExpression &boundary, const idx_t chunk_idx, const FrameBounds &prev) {
+                                 const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
+                                 const FrameBounds &prev) {
 	D_ASSERT(!boundary.CellIsNull(chunk_idx));
 	const auto val = boundary.GetCell<T>(chunk_idx);
 
 	OperationCompare<T, OP> comp;
-	WindowColumnIterator<T> begin(over, order_begin);
-	WindowColumnIterator<T> end(over, order_end);
+
+	// Check that the value we are searching for is in range.
+	if (range == WindowBoundary::EXPR_PRECEDING_RANGE) {
+		//	Preceding but value past the end
+		const auto cur_val = over.GetCell<T>(order_end);
+		if (comp(cur_val, val)) {
+			throw OutOfRangeException("Invalid RANGE PRECEDING value");
+		}
+	} else {
+		//	Following but value before beginning
+		D_ASSERT(range == WindowBoundary::EXPR_FOLLOWING_RANGE);
+		const auto cur_val = over.GetCell<T>(order_begin);
+		if (comp(val, cur_val)) {
+			throw OutOfRangeException("Invalid RANGE FOLLOWING value");
+		}
+	}
 
 	//	Try to reuse the previous bounds to restrict the search.
 	//	This is only valid if the previous bounds were non-empty
 	//	Only inject the comparisons if the previous bounds are a strict subset.
+	WindowColumnIterator<T> begin(over, order_begin);
+	WindowColumnIterator<T> end(over, order_end);
 	if (prev.start < prev.end) {
 		if (order_begin < prev.start && prev.start < order_end) {
 			const auto first = over.GetCell<T>(prev.start);
@@ -237,37 +254,40 @@ static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t orde
 
 template <typename OP, bool FROM>
 static idx_t FindRangeBound(const WindowInputColumn &over, const idx_t order_begin, const idx_t order_end,
-                            WindowInputExpression &boundary, const idx_t chunk_idx, const FrameBounds &prev) {
+                            const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
+                            const FrameBounds &prev) {
 	D_ASSERT(boundary.chunk.ColumnCount() == 1);
 	D_ASSERT(boundary.chunk.data[0].GetType().InternalType() == over.input_expr.ptype);
 
 	switch (over.input_expr.ptype) {
 	case PhysicalType::INT8:
-		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::INT16:
-		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::INT32:
-		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::INT64:
-		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::UINT8:
-		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::UINT16:
-		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::UINT32:
-		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::UINT64:
-		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::INT128:
-		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::UINT128:
-		return FindTypedRangeBound<uhugeint_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uhugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
+		                                                 prev);
 	case PhysicalType::FLOAT:
-		return FindTypedRangeBound<float, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<float, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::DOUBLE:
-		return FindTypedRangeBound<double, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<double, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case PhysicalType::INTERVAL:
-		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
+		                                                 prev);
 	default:
 		throw InternalException("Unsupported column type for RANGE");
 	}
@@ -275,13 +295,13 @@ static idx_t FindRangeBound(const WindowInputColumn &over, const idx_t order_beg
 
 template <bool FROM>
 static idx_t FindOrderedRangeBound(const WindowInputColumn &over, const OrderType range_sense, const idx_t order_begin,
-                                   const idx_t order_end, WindowInputExpression &boundary, const idx_t chunk_idx,
-                                   const FrameBounds &prev) {
+                                   const idx_t order_end, const WindowBoundary range, WindowInputExpression &boundary,
+                                   const idx_t chunk_idx, const FrameBounds &prev) {
 	switch (range_sense) {
 	case OrderType::ASCENDING:
-		return FindRangeBound<LessThan, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindRangeBound<LessThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	case OrderType::DESCENDING:
-		return FindRangeBound<GreaterThan, FROM>(over, order_begin, order_end, boundary, chunk_idx, prev);
+		return FindRangeBound<GreaterThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
 	default:
 		throw InternalException("Unsupported ORDER BY sense for RANGE");
 	}
@@ -458,7 +478,7 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 			window_start = peer_start;
 		} else {
 			prev.start = FindOrderedRangeBound<true>(range_collection, range_sense, valid_start, row_idx,
-			                                         boundary_start, chunk_idx, prev);
+			                                         start_boundary, boundary_start, chunk_idx, prev);
 			window_start = prev.start;
 		}
 		break;
@@ -467,8 +487,8 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		if (boundary_start.CellIsNull(chunk_idx)) {
 			window_start = peer_start;
 		} else {
-			prev.start = FindOrderedRangeBound<true>(range_collection, range_sense, row_idx, valid_end, boundary_start,
-			                                         chunk_idx, prev);
+			prev.start = FindOrderedRangeBound<true>(range_collection, range_sense, row_idx, valid_end, start_boundary,
+			                                         boundary_start, chunk_idx, prev);
 			window_start = prev.start;
 		}
 		break;
@@ -502,8 +522,8 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		if (boundary_end.CellIsNull(chunk_idx)) {
 			window_end = peer_end;
 		} else {
-			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, valid_start, row_idx, boundary_end,
-			                                        chunk_idx, prev);
+			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, valid_start, row_idx, end_boundary,
+			                                        boundary_end, chunk_idx, prev);
 			window_end = prev.end;
 		}
 		break;
@@ -512,8 +532,8 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		if (boundary_end.CellIsNull(chunk_idx)) {
 			window_end = peer_end;
 		} else {
-			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, row_idx, valid_end, boundary_end,
-			                                        chunk_idx, prev);
+			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, row_idx, valid_end, end_boundary,
+			                                        boundary_end, chunk_idx, prev);
 			window_end = prev.end;
 		}
 		break;

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

@@ -18,9 +18,9 @@ namespace duckdb {
 WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) {
 }
 
-WindowAggregator::WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p,
+WindowAggregator::WindowAggregator(AggregateObject aggr_p, const LogicalType &result_type_p,
                                    const WindowExcludeMode exclude_mode_p, idx_t partition_count_p)
-    : aggr(std::move(aggr)), result_type(result_type_p), partition_count(partition_count_p),
+    : aggr(std::move(aggr_p)), result_type(result_type_p), partition_count(partition_count_p),
       state_size(aggr.function.state_size()), filter_pos(0), exclude_mode(exclude_mode_p) {
 }
 
@@ -470,7 +470,7 @@ WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &gstate)
       row_set(STANDARD_VECTOR_SIZE, hash_row, equal_row) {
 	InitSubFrames(frames, gstate.exclude_mode);
 
-	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
+	auto &inputs = gstate.GetInputs();
 	if (inputs.ColumnCount() > 0) {
 		leaves.Initialize(Allocator::DefaultAllocator(), inputs.GetTypes());
 	}
@@ -494,9 +494,8 @@ void WindowNaiveState::FlushStates() {
 		return;
 	}
 
-	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
-	leaves.Reference(inputs);
-	leaves.Slice(update_sel, flush_count);
+	auto &inputs = gstate.GetInputs();
+	leaves.Slice(inputs, update_sel, flush_count);
 
 	auto &aggr = gstate.aggr;
 	AggregateInputData aggr_input_data(aggr.GetFunctionData(), allocator);
@@ -506,19 +505,18 @@ void WindowNaiveState::FlushStates() {
 }
 
 size_t WindowNaiveState::Hash(idx_t rid) {
-	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
-	leaves.Reference(inputs);
+	auto &inputs = gstate.GetInputs();
 
 	auto s = UnsafeNumericCast<sel_t>(rid);
 	SelectionVector sel(&s);
-	leaves.Slice(sel, 1);
+	leaves.Slice(inputs, sel, 1);
 	leaves.Hash(hashes);
 
 	return *FlatVector::GetData<hash_t>(hashes);
 }
 
 bool WindowNaiveState::KeyEqual(const idx_t &lhs, const idx_t &rhs) {
-	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
+	auto &inputs = gstate.GetInputs();
 
 	auto l = UnsafeNumericCast<sel_t>(lhs);
 	SelectionVector lsel(&l);
@@ -644,7 +642,7 @@ public:
 
 	enum FramePart : uint8_t { FULL = 0, LEFT = 1, RIGHT = 2 };
 
-	WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr, DataChunk &inputs,
+	WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr, const DataChunk &inputs,
 	                      const ValidityMask &filter_mask);
 	~WindowSegmentTreePart();
 
@@ -681,7 +679,7 @@ public:
 	//! Order insensitive aggregate (we can optimise internal combines)
 	const bool order_insensitive;
 	//! The partition arguments
-	DataChunk &inputs;
+	const DataChunk &inputs;
 	//! The filtered rows in inputs
 	const ValidityMask &filter_mask;
 	//! The size of a single aggregate state
@@ -706,14 +704,14 @@ public:
 
 class WindowSegmentTreeState : public WindowAggregatorState {
 public:
-	WindowSegmentTreeState(const AggregateObject &aggr, DataChunk &inputs, const ValidityMask &filter_mask)
+	WindowSegmentTreeState(const AggregateObject &aggr, const DataChunk &inputs, const ValidityMask &filter_mask)
 	    : aggr(aggr), inputs(inputs), filter_mask(filter_mask), part(allocator, aggr, inputs, filter_mask) {
 	}
 
 	//! The aggregate function
 	const AggregateObject &aggr;
 	//! The aggregate function
-	DataChunk &inputs;
+	const DataChunk &inputs;
 	//! The filtered rows in inputs
 	const ValidityMask &filter_mask;
 	//! The left (default) segment tree part
@@ -722,8 +720,8 @@ public:
 	unique_ptr<WindowSegmentTreePart> right_part;
 };
 
-WindowSegmentTreePart::WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr, DataChunk &inputs,
-                                             const ValidityMask &filter_mask)
+WindowSegmentTreePart::WindowSegmentTreePart(ArenaAllocator &allocator, const AggregateObject &aggr,
+                                             const DataChunk &inputs, const ValidityMask &filter_mask)
     : allocator(allocator), aggr(aggr),
       order_insensitive(aggr.function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT), inputs(inputs),
       filter_mask(filter_mask), state_size(aggr.function.state_size()), state(state_size * STANDARD_VECTOR_SIZE),
@@ -749,7 +747,7 @@ WindowSegmentTreePart::~WindowSegmentTreePart() {
 }
 
 unique_ptr<WindowAggregatorState> WindowSegmentTree::GetLocalState() const {
-	return make_uniq<WindowSegmentTreeState>(aggr, const_cast<DataChunk &>(inputs), filter_mask);
+	return make_uniq<WindowSegmentTreeState>(aggr, inputs, filter_mask);
 }
 
 void WindowSegmentTreePart::FlushStates(bool combining) {
@@ -762,8 +760,7 @@ void WindowSegmentTreePart::FlushStates(bool 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);
+		leaves.Slice(inputs, filter_sel, flush_count);
 		aggr.function.update(&leaves.data[0], aggr_input_data, leaves.ColumnCount(), statep, flush_count);
 	}
 
@@ -1382,7 +1379,7 @@ WindowDistinctAggregator::DistinctSortTree::DistinctSortTree(ZippedElements &&pr
 
 class WindowDistinctState : public WindowAggregatorState {
 public:
-	WindowDistinctState(const AggregateObject &aggr, DataChunk &inputs, const WindowDistinctAggregator &tree);
+	WindowDistinctState(const AggregateObject &aggr, const DataChunk &inputs, const WindowDistinctAggregator &tree);
 
 	void Evaluate(const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx);
 
@@ -1393,7 +1390,7 @@ protected:
 	//! The aggregate function
 	const AggregateObject &aggr;
 	//! The aggregate function
-	DataChunk &inputs;
+	const DataChunk &inputs;
 	//! The merge sort tree data
 	const WindowDistinctAggregator &tree;
 	//! The size of a single aggregate state
@@ -1412,7 +1409,7 @@ protected:
 	SubFrames frames;
 };
 
-WindowDistinctState::WindowDistinctState(const AggregateObject &aggr, DataChunk &inputs,
+WindowDistinctState::WindowDistinctState(const AggregateObject &aggr, const DataChunk &inputs,
                                          const WindowDistinctAggregator &tree)
     : aggr(aggr), inputs(inputs), tree(tree), state_size(aggr.function.state_size()),
       state((state_size * STANDARD_VECTOR_SIZE)), statef(LogicalType::POINTER), statep(LogicalType::POINTER),
@@ -1488,7 +1485,7 @@ void WindowDistinctState::Evaluate(const DataChunk &bounds, Vector &result, idx_
 }
 
 unique_ptr<WindowAggregatorState> WindowDistinctAggregator::GetLocalState() const {
-	return make_uniq<WindowDistinctState>(aggr, const_cast<DataChunk &>(inputs), *this);
+	return make_uniq<WindowDistinctState>(aggr, inputs, *this);
 }
 
 void WindowDistinctAggregator::Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result,

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -538,7 +538,7 @@ struct SortedAggregateFunction {
 	template <class STATE, class OP>
 	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
 		auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
-		auto &other = const_cast<STATE &>(source);
+		auto &other = const_cast<STATE &>(source); // NOLINT: absorb explicitly allows destruction
 		target.Absorb(order_bind, other);
 	}