duckdb 1.3.2 → 1.3.3-dev4.0

package/src/duckdb/src/function/table/table_scan.cpp

@@ -2,15 +2,19 @@
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/unique_ptr.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_config.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
-#include "duckdb/planner/expression/bound_between_expression.hpp"
+#include "duckdb/planner/expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
@@ -25,7 +29,7 @@
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/common/types/value_map.hpp"
-
+#include "duckdb/main/settings.hpp"
 #include <list>
 
 namespace duckdb {
@@ -109,14 +113,19 @@ public:
 class DuckIndexScanState : public TableScanGlobalState {
 public:
 	DuckIndexScanState(ClientContext &context, const FunctionData *bind_data_p)
-	    : TableScanGlobalState(context, bind_data_p), next_batch_index(0), finished(false) {
+	    : TableScanGlobalState(context, bind_data_p), next_batch_index(0), arena(Allocator::Get(context)),
+	      row_ids(nullptr), row_id_count(0), finished(false) {
 	}
 
 	//! The batch index of the next Sink.
 	//! Also determines the offset of the next chunk. I.e., offset = next_batch_index * STANDARD_VECTOR_SIZE.
 	atomic<idx_t> next_batch_index;
-	//! The total scanned row IDs.
-	unsafe_vector<row_t> row_ids;
+	//! The arena allocator containing the memory of the row IDs.
+	ArenaAllocator arena;
+	//! A pointer to the row IDs.
+	row_t *row_ids;
+	//! The number of scanned row IDs.
+	idx_t row_id_count;
 	//! The column IDs of the to-be-scanned columns.
 	vector<StorageIndex> column_ids;
 	//! True, if no more row IDs must be scanned.
@@ -154,7 +163,6 @@ public:
 		auto &storage = duck_table.GetStorage();
 		auto &l_state = data_p.local_state->Cast<IndexScanLocalState>();
 
-		auto row_id_count = row_ids.size();
 		idx_t scan_count = 0;
 		idx_t offset = 0;
 
@@ -173,7 +181,7 @@ public:
 		}
 
 		if (scan_count != 0) {
-			auto row_id_data = (data_ptr_t)&row_ids[0 + offset]; // NOLINT - this is not pretty
+			auto row_id_data = reinterpret_cast<data_ptr_t>(row_ids + offset);
 			Vector local_vector(LogicalType::ROW_TYPE, row_id_data);
 
 			if (CanRemoveFilterColumns()) {
@@ -198,13 +206,11 @@ public:
 	}
 
 	double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override {
-		auto total_rows = row_ids.size();
-		if (total_rows == 0) {
+		if (row_id_count == 0) {
 			return 100;
 		}
-
 		auto scanned_rows = next_batch_index * STANDARD_VECTOR_SIZE;
-		auto percentage = 100 * (static_cast<double>(scanned_rows) / static_cast<double>(total_rows));
+		auto percentage = 100 * (static_cast<double>(scanned_rows) / static_cast<double>(row_id_count));
 		return percentage > 100 ? 100 : percentage;
 	}
 
@@ -218,15 +224,24 @@ public:
 class DuckTableScanState : public TableScanGlobalState {
 public:
 	DuckTableScanState(ClientContext &context, const FunctionData *bind_data_p)
-	    : TableScanGlobalState(context, bind_data_p) {
+	    : TableScanGlobalState(context, bind_data_p), bind_data(bind_data_p->Cast<TableScanBindData>()),
+	      duck_table(bind_data.table.Cast<DuckTableEntry>()), tx(DuckTransaction::Get(context, duck_table.catalog)),
+	      storage(duck_table.GetStorage()), total_rows(storage.GetTotalRows()) {
 	}
 
+public:
 	ParallelTableScanState state;
 
+private:
+	const TableScanBindData &bind_data;
+	DuckTableEntry &duck_table;
+	DuckTransaction &tx;
+	DataTable &storage;
+	const idx_t total_rows;
+
 public:
 	unique_ptr<LocalTableFunctionState> InitLocalState(ExecutionContext &context,
 	                                                   TableFunctionInitInput &input) override {
-		auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 		auto l_state = make_uniq<TableScanLocalState>();
 
 		vector<StorageIndex> storage_ids;
@@ -236,8 +251,6 @@ public:
 
 		l_state->scan_state.Initialize(std::move(storage_ids), context.client, input.filters, input.sample_options);
 
-		auto &duck_table = bind_data.table.Cast<DuckTableEntry>();
-		auto &storage = duck_table.GetStorage();
 		storage.NextParallelScan(context.client, state, l_state->scan_state);
 		if (input.CanRemoveFilterColumns()) {
 			l_state->all_columns.Initialize(context.client, scanned_types);
@@ -248,15 +261,13 @@ public:
 	}
 
 	void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override {
-		auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
-		auto &duck_table = bind_data.table.Cast<DuckTableEntry>();
-		auto &tx = DuckTransaction::Get(context, duck_table.catalog);
-		auto &storage = duck_table.GetStorage();
-
 		auto &l_state = data_p.local_state->Cast<TableScanLocalState>();
 		l_state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row;
 
 		do {
+			if (context.interrupted) {
+				throw InterruptException();
+			}
 			if (bind_data.is_create_index) {
 				storage.CreateIndexScan(l_state.scan_state, output,
 				                        TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
@@ -279,11 +290,6 @@ public:
 	}
 
 	double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override {
-		auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-		auto &duck_table = bind_data.table.Cast<DuckTableEntry>();
-		auto &storage = duck_table.GetStorage();
-		auto total_rows = storage.GetTotalRows();
-
 		// The table is empty or smaller than the standard vector size.
 		if (total_rows == 0) {
 			return 100;
@@ -342,26 +348,20 @@ unique_ptr<GlobalTableFunctionState> DuckTableScanInitGlobal(ClientContext &cont
 }
 
 unique_ptr<GlobalTableFunctionState> DuckIndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input,
-                                                             const TableScanBindData &bind_data,
-                                                             unsafe_vector<row_t> &row_ids) {
+                                                             const TableScanBindData &bind_data, set<row_t> &row_ids) {
 	auto g_state = make_uniq<DuckIndexScanState>(context, input.bind_data.get());
+	g_state->finished = row_ids.empty() ? true : false;
+
 	if (!row_ids.empty()) {
-		// Duplicate-eliminate row IDs.
-		unordered_set<row_t> row_id_set;
-		auto it = row_ids.begin();
-		while (it != row_ids.end()) {
-			if (row_id_set.find(*it) == row_id_set.end()) {
-				row_id_set.insert(*it++);
-				continue;
-			}
-			// Found a duplicate.
-			it = row_ids.erase(it);
-		}
+		auto row_id_ptr = g_state->arena.AllocateAligned(row_ids.size() * sizeof(row_t));
+		g_state->row_ids = reinterpret_cast<row_t *>(row_id_ptr);
+		g_state->row_id_count = row_ids.size();
 
-		std::sort(row_ids.begin(), row_ids.end());
-		g_state->row_ids = std::move(row_ids);
+		idx_t row_id_count = 0;
+		for (const auto row_id : row_ids) {
+			g_state->row_ids[row_id_count++] = row_id;
+		}
 	}
-	g_state->finished = g_state->row_ids.empty() ? true : false;
 
 	auto &duck_table = bind_data.table.Cast<DuckTableEntry>();
 	if (input.CanRemoveFilterColumns()) {
@@ -485,7 +485,7 @@ vector<unique_ptr<Expression>> ExtractFilterExpressions(const ColumnDefinition &
 }
 
 bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInput &input, TableFilterSet &filter_set,
-                  idx_t max_count, unsafe_vector<row_t> &row_ids) {
+                  idx_t max_count, set<row_t> &row_ids) {
 	// FIXME: No support for index scans on compound ARTs.
 	// See note above on multi-filter support.
 	if (art.unbound_expressions.size() > 1) {
@@ -500,6 +500,35 @@ bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInpu
 		return false;
 	}
 
+	// Resolve bound column references in the index_expr against the current input projection
+	column_t updated_index_column;
+	bool found_index_column_in_input = false;
+
+	// Find the indexed column amongst the input columns
+	for (idx_t i = 0; i < input.column_ids.size(); ++i) {
+		if (input.column_ids[i] == indexed_columns[0]) {
+			updated_index_column = i;
+			found_index_column_in_input = true;
+			break;
+		}
+	}
+
+	// If found, update the bound column ref within index_expr
+	if (found_index_column_in_input) {
+		ExpressionIterator::EnumerateExpression(index_expr, [&](Expression &expr) {
+			if (expr.GetExpressionClass() != ExpressionClass::BOUND_COLUMN_REF) {
+				return;
+			}
+
+			auto &bound_column_ref_expr = expr.Cast<BoundColumnRefExpression>();
+
+			// If the bound column references the index column, use updated_index_column
+			if (bound_column_ref_expr.binding.column_index == indexed_columns[0]) {
+				bound_column_ref_expr.binding.column_index = updated_index_column;
+			}
+		});
+	}
+
 	// Get ART column.
 	auto &col = column_list.GetColumn(LogicalIndex(indexed_columns[0]));
 
@@ -572,9 +601,8 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 		return DuckTableScanInitGlobal(context, input, storage, bind_data);
 	}
 
-	auto &db_config = DBConfig::GetConfig(context);
-	auto scan_percentage = db_config.GetSetting<IndexScanPercentageSetting>(context);
-	auto scan_max_count = db_config.GetSetting<IndexScanMaxCountSetting>(context);
+	auto scan_percentage = DBConfig::GetSetting<IndexScanPercentageSetting>(context);
+	auto scan_max_count = DBConfig::GetSetting<IndexScanMaxCountSetting>(context);
 
 	auto total_rows = storage.GetTotalRows();
 	auto total_rows_from_percentage = LossyNumericCast<idx_t>(double(total_rows) * scan_percentage);
@@ -582,9 +610,15 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 
 	auto &column_list = duck_table.GetColumns();
 	bool index_scan = false;
-	unsafe_vector<row_t> row_ids;
+	set<row_t> row_ids;
 
-	info->GetIndexes().BindAndScan<ART>(context, *info, [&](ART &art) {
+	info->BindIndexes(context, ART::TYPE_NAME);
+	info->GetIndexes().Scan([&](Index &index) {
+		if (index.GetIndexType() != ART::TYPE_NAME) {
+			return false;
+		}
+		D_ASSERT(index.IsBound());
+		auto &art = index.Cast<ART>();
 		index_scan = TryScanIndex(art, column_list, input, filter_set, max_count, row_ids);
 		return index_scan;
 	});

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,17 +1,17 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "2"
+#define DUCKDB_PATCH_VERSION "0"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
-#define DUCKDB_MINOR_VERSION 3
+#define DUCKDB_MINOR_VERSION 4
 #endif
 #ifndef DUCKDB_MAJOR_VERSION
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.3.2"
+#define DUCKDB_VERSION "v1.4.0"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "0b83e5d2f6"
+#define DUCKDB_SOURCE_ID "b8a06e4a22"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
@@ -88,6 +88,9 @@ const char *DuckDB::ReleaseCodename() {
 	if (StringUtil::StartsWith(DUCKDB_VERSION, "v1.3.")) {
 		return "Ossivalis";
 	}
+	if (StringUtil::StartsWith(DUCKDB_VERSION, "v1.4.")) {
+		return "Andium";
+	}
 	// add new version names here
 
 	// we should not get here, but let's not fail because of it because tags on forks can be whatever

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

@@ -16,11 +16,12 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class WindowAggregateExecutorGlobalState : public WindowExecutorGlobalState {
 public:
-	WindowAggregateExecutorGlobalState(const WindowAggregateExecutor &executor, const idx_t payload_count,
-	                                   const ValidityMask &partition_mask, const ValidityMask &order_mask);
+	WindowAggregateExecutorGlobalState(ClientContext &client, const WindowAggregateExecutor &executor,
+	                                   const idx_t payload_count, const ValidityMask &partition_mask,
+	                                   const ValidityMask &order_mask);
 
 	// aggregate global state
-	unique_ptr<WindowAggregatorState> gsink;
+	unique_ptr<GlobalSinkState> gsink;
 
 	// the filter reference expression.
 	const Expression *filter_ref;
@@ -48,28 +49,36 @@ static BoundWindowExpression &SimplifyWindowedAggregate(BoundWindowExpression &w
 	return wexpr;
 }
 
-WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context,
+WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &client,
                                                  WindowSharedExpressions &shared, WindowAggregationMode mode)
-    : WindowExecutor(SimplifyWindowedAggregate(wexpr, context), context, shared), mode(mode) {
+    : WindowExecutor(SimplifyWindowedAggregate(wexpr, client), shared), mode(mode) {
 
 	// Force naive for SEPARATE mode or for (currently!) unsupported functionality
-	if (!ClientConfig::GetConfig(context).enable_optimizer || mode == WindowAggregationMode::SEPARATE) {
+	if (!ClientConfig::GetConfig(client).enable_optimizer || mode == WindowAggregationMode::SEPARATE) {
+		if (!WindowNaiveAggregator::CanAggregate(wexpr)) {
+			throw InvalidInputException("Cannot use non-aggregate window function with naive window executor!");
+		}
 		aggregator = make_uniq<WindowNaiveAggregator>(*this, shared);
 	} else if (WindowDistinctAggregator::CanAggregate(wexpr)) {
 		// build a merge sort tree
 		// see https://dl.acm.org/doi/pdf/10.1145/3514221.3526184
-		aggregator = make_uniq<WindowDistinctAggregator>(wexpr, shared, context);
+		aggregator = make_uniq<WindowDistinctAggregator>(wexpr, shared, client);
 	} else if (WindowConstantAggregator::CanAggregate(wexpr)) {
-		aggregator = make_uniq<WindowConstantAggregator>(wexpr, shared, context);
+		aggregator = make_uniq<WindowConstantAggregator>(wexpr, shared, client);
 	} else if (WindowCustomAggregator::CanAggregate(wexpr, mode)) {
 		aggregator = make_uniq<WindowCustomAggregator>(wexpr, shared);
 	} else if (WindowSegmentTree::CanAggregate(wexpr)) {
 		// build a segment tree for frame-adhering aggregates
 		// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
 		aggregator = make_uniq<WindowSegmentTree>(wexpr, shared);
-	} else {
+	} else if (WindowNaiveAggregator::CanAggregate(wexpr)) {
 		// No accelerator can handle this combination, so fall back to naïve.
 		aggregator = make_uniq<WindowNaiveAggregator>(*this, shared);
+	} else {
+		// This shouldn't happen, if we get here, the binder messed up
+		// Non-aggregate window functions that can't be handled by the WindowCustomAggregator due to e.g. a ORDER BY
+		// clause should have been caught in the binder.
+		throw InternalException("Could not create a window aggregator with the given parameters!");
 	}
 
 	// Compute the FILTER with the other eval columns.
@@ -80,28 +89,31 @@ WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, C
 	}
 }
 
-WindowAggregateExecutorGlobalState::WindowAggregateExecutorGlobalState(const WindowAggregateExecutor &executor,
+WindowAggregateExecutorGlobalState::WindowAggregateExecutorGlobalState(ClientContext &client,
+                                                                       const WindowAggregateExecutor &executor,
                                                                        const idx_t group_count,
                                                                        const ValidityMask &partition_mask,
                                                                        const ValidityMask &order_mask)
-    : WindowExecutorGlobalState(executor, group_count, partition_mask, order_mask),
+    : WindowExecutorGlobalState(client, executor, group_count, partition_mask, order_mask),
       filter_ref(executor.filter_ref.get()) {
-	gsink = executor.aggregator->GetGlobalState(executor.context, group_count, partition_mask);
+	gsink = executor.aggregator->GetGlobalState(client, group_count, partition_mask);
 }
 
-unique_ptr<WindowExecutorGlobalState> WindowAggregateExecutor::GetGlobalState(const idx_t payload_count,
-                                                                              const ValidityMask &partition_mask,
-                                                                              const ValidityMask &order_mask) const {
-	return make_uniq<WindowAggregateExecutorGlobalState>(*this, payload_count, partition_mask, order_mask);
+unique_ptr<GlobalSinkState> WindowAggregateExecutor::GetGlobalState(ClientContext &client, const idx_t payload_count,
+                                                                    const ValidityMask &partition_mask,
+                                                                    const ValidityMask &order_mask) const {
+	return make_uniq<WindowAggregateExecutorGlobalState>(client, *this, payload_count, partition_mask, order_mask);
 }
 
-class WindowAggregateExecutorLocalState : public WindowExecutorBoundsState {
+class WindowAggregateExecutorLocalState : public WindowExecutorBoundsLocalState {
 public:
-	WindowAggregateExecutorLocalState(const WindowExecutorGlobalState &gstate, const WindowAggregator &aggregator)
-	    : WindowExecutorBoundsState(gstate), filter_executor(gstate.executor.context) {
+	WindowAggregateExecutorLocalState(ExecutionContext &context, const GlobalSinkState &gstate,
+	                                  const WindowAggregator &aggregator)
+	    : WindowExecutorBoundsLocalState(context, gstate.Cast<WindowAggregateExecutorGlobalState>()),
+	      filter_executor(context.client) {
 
 		auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-		aggregator_state = aggregator.GetLocalState(*gastate.gsink);
+		aggregator_state = aggregator.GetLocalState(context, *gastate.gsink);
 
 		// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
 		auto filter_ref = gastate.filter_ref;
@@ -113,22 +125,22 @@ public:
 
 public:
 	// state of aggregator
-	unique_ptr<WindowAggregatorState> aggregator_state;
+	unique_ptr<LocalSinkState> aggregator_state;
 	//! Executor for any filter clause
 	ExpressionExecutor filter_executor;
 	//! Result of filtering
 	SelectionVector filter_sel;
 };
 
-unique_ptr<WindowExecutorLocalState>
-WindowAggregateExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const {
-	return make_uniq<WindowAggregateExecutorLocalState>(gstate, *aggregator);
+unique_ptr<LocalSinkState> WindowAggregateExecutor::GetLocalState(ExecutionContext &context,
+                                                                  const GlobalSinkState &gstate) const {
+	return make_uniq<WindowAggregateExecutorLocalState>(context, gstate, *aggregator);
 }
 
-void WindowAggregateExecutor::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx,
-                                   WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const {
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
+void WindowAggregateExecutor::Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk,
+                                   const idx_t input_idx, OperatorSinkInput &sink) const {
+	auto &gastate = sink.global_state.Cast<WindowAggregateExecutorGlobalState>();
+	auto &lastate = sink.local_state.Cast<WindowAggregateExecutorLocalState>();
 	auto &filter_sel = lastate.filter_sel;
 	auto &filter_executor = lastate.filter_executor;
 
@@ -140,11 +152,10 @@ void WindowAggregateExecutor::Sink(DataChunk &sink_chunk, DataChunk &coll_chunk,
 	}
 
 	D_ASSERT(aggregator);
-	auto &gestate = *gastate.gsink;
-	auto &lestate = *lastate.aggregator_state;
-	aggregator->Sink(gestate, lestate, sink_chunk, coll_chunk, input_idx, filtering, filtered);
+	OperatorSinkInput asink {*gastate.gsink, *lastate.aggregator_state, sink.interrupt_state};
+	aggregator->Sink(context, sink_chunk, coll_chunk, input_idx, filtering, filtered, asink);
 
-	WindowExecutor::Sink(sink_chunk, coll_chunk, input_idx, gstate, lstate);
+	WindowExecutor::Sink(context, sink_chunk, coll_chunk, input_idx, sink);
 }
 
 static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta, BaseStatistics *base, bool is_start) {
@@ -210,11 +221,11 @@ static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta,
 	}
 }
 
-void WindowAggregateExecutor::Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                       CollectionPtr collection) const {
-	WindowExecutor::Finalize(gstate, lstate, collection);
+void WindowAggregateExecutor::Finalize(ExecutionContext &context, CollectionPtr collection,
+                                       OperatorSinkInput &sink) const {
+	WindowExecutor::Finalize(context, collection, sink);
 
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
+	auto &gastate = sink.global_state.Cast<WindowAggregateExecutorGlobalState>();
 	auto &gsink = gastate.gsink;
 	D_ASSERT(aggregator);
 
@@ -233,21 +244,20 @@ void WindowAggregateExecutor::Finalize(WindowExecutorGlobalState &gstate, Window
 	base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[1].get();
 	ApplyWindowStats(wexpr.end, stats[1], base, false);
 
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
-	aggregator->Finalize(*gsink, *lastate.aggregator_state, collection, stats);
+	auto &lastate = sink.local_state.Cast<WindowAggregateExecutorLocalState>();
+	OperatorSinkInput asink {*gsink, *lastate.aggregator_state, sink.interrupt_state};
+	aggregator->Finalize(context, collection, stats, asink);
 }
 
-void WindowAggregateExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate,
-                                               DataChunk &eval_chunk, Vector &result, idx_t count,
-                                               idx_t row_idx) const {
-	auto &gastate = gstate.Cast<WindowAggregateExecutorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregateExecutorLocalState>();
+void WindowAggregateExecutor::EvaluateInternal(ExecutionContext &context, DataChunk &eval_chunk, Vector &result,
+                                               idx_t count, idx_t row_idx, OperatorSinkInput &sink) const {
+	auto &gastate = sink.global_state.Cast<WindowAggregateExecutorGlobalState>();
+	auto &lastate = sink.local_state.Cast<WindowAggregateExecutorLocalState>();
 	auto &gsink = gastate.gsink;
 	D_ASSERT(aggregator);
 
-	auto &agg_state = *lastate.aggregator_state;
-
-	aggregator->Evaluate(*gsink, agg_state, lastate.bounds, result, count, row_idx);
+	OperatorSinkInput asink {*gsink, *lastate.aggregator_state, sink.interrupt_state};
+	aggregator->Evaluate(context, lastate.bounds, result, count, row_idx, asink);
 }
 
 } // namespace duckdb

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

@@ -9,9 +9,6 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // WindowAggregator
 //===--------------------------------------------------------------------===//
-WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) {
-}
-
 WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr)
     : wexpr(wexpr), aggr(wexpr), result_type(wexpr.return_type), state_size(aggr.function.state_size(aggr.function)),
       exclude_mode(wexpr.exclude_clause) {
@@ -31,21 +28,37 @@ WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr, WindowSha
 WindowAggregator::~WindowAggregator() {
 }
 
-unique_ptr<WindowAggregatorState> WindowAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
-                                                                   const ValidityMask &) const {
+WindowAggregatorGlobalState::WindowAggregatorGlobalState(ClientContext &client, const WindowAggregator &aggregator_p,
+                                                         idx_t group_count)
+    : client(client), allocator(Allocator::DefaultAllocator()), aggregator(aggregator_p), aggr(aggregator.wexpr),
+      locals(0), finalized(0) {
+
+	if (aggr.filter) {
+		// 	Start with all invalid and set the ones that pass
+		filter_mask.Initialize(group_count, false);
+	} else {
+		filter_mask.InitializeEmpty(group_count);
+	}
+}
+
+unique_ptr<GlobalSinkState> WindowAggregator::GetGlobalState(ClientContext &context, idx_t group_count,
+                                                             const ValidityMask &) const {
 	return make_uniq<WindowAggregatorGlobalState>(context, *this, group_count);
 }
 
-void WindowAggregatorLocalState::Sink(WindowAggregatorGlobalState &gastate, DataChunk &sink_chunk,
-                                      DataChunk &coll_chunk, idx_t input_idx) {
+WindowAggregatorLocalState::WindowAggregatorLocalState(ExecutionContext &context)
+    : allocator(Allocator::DefaultAllocator()) {
+}
+
+void WindowAggregatorLocalState::Sink(ExecutionContext &context, WindowAggregatorGlobalState &gastate,
+                                      DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx) {
 }
 
-void WindowAggregator::Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &sink_chunk,
-                            DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
-                            idx_t filtered) {
-	auto &gastate = gstate.Cast<WindowAggregatorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregatorLocalState>();
-	lastate.Sink(gastate, sink_chunk, coll_chunk, input_idx);
+void WindowAggregator::Sink(ExecutionContext &context, DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx,
+                            optional_ptr<SelectionVector> filter_sel, idx_t filtered, OperatorSinkInput &sink) {
+	auto &gastate = sink.global_state.Cast<WindowAggregatorGlobalState>();
+	auto &lastate = sink.local_state.Cast<WindowAggregatorLocalState>();
+	lastate.Sink(context, gastate, sink_chunk, coll_chunk, input_idx);
 	if (filter_sel) {
 		auto &filter_mask = gastate.filter_mask;
 		for (idx_t f = 0; f < filtered; ++f) {
@@ -71,18 +84,19 @@ void WindowAggregatorLocalState::InitSubFrames(SubFrames &frames, const WindowEx
 	frames.resize(nframes, {0, 0});
 }
 
-void WindowAggregatorLocalState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) {
+void WindowAggregatorLocalState::Finalize(ExecutionContext &context, WindowAggregatorGlobalState &gastate,
+                                          CollectionPtr collection) {
 	// Prepare to scan
 	if (!cursor) {
 		cursor = make_uniq<WindowCursor>(*collection, gastate.aggregator.child_idx);
 	}
 }
 
-void WindowAggregator::Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, CollectionPtr collection,
-                                const FrameStats &stats) {
-	auto &gasink = gstate.Cast<WindowAggregatorGlobalState>();
-	auto &lastate = lstate.Cast<WindowAggregatorLocalState>();
-	lastate.Finalize(gasink, collection);
+void WindowAggregator::Finalize(ExecutionContext &context, CollectionPtr collection, const FrameStats &stats,
+                                OperatorSinkInput &sink) {
+	auto &gasink = sink.global_state.Cast<WindowAggregatorGlobalState>();
+	auto &lastate = sink.local_state.Cast<WindowAggregatorLocalState>();
+	lastate.Finalize(context, gasink, collection);
 }
 
 } // namespace duckdb

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

@@ -388,6 +388,16 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi
 			result.insert(FRAME_END);
 		}
 		break;
+	case ExpressionType::WINDOW_FILL:
+		result.insert(FRAME_BEGIN);
+		result.insert(FRAME_END);
+		if (wexpr.arg_orders.empty()) {
+			//	FILL uses the validity ranges to quickly eliminate indexes that can't be interpolated.
+			//	This only works for non-secondary orderings
+			result.insert(VALID_BEGIN);
+			result.insert(VALID_END);
+		}
+		break;
 	case ExpressionType::WINDOW_FIRST_VALUE:
 	case ExpressionType::WINDOW_LAST_VALUE:
 	case ExpressionType::WINDOW_NTH_VALUE:
@@ -687,7 +697,7 @@ void WindowBoundariesState::ValidBegin(DataChunk &bounds, idx_t row_idx, const i
 			valid_start = partition_begin_data[chunk_idx];
 			const auto valid_end = partition_end_data[chunk_idx];
 
-			if ((valid_start < valid_end) && has_preceding_range) {
+			if (valid_start < valid_end) {
 				// Exclude any leading NULLs
 				if (range->CellIsNull(0, valid_start)) {
 					idx_t n = 1;
@@ -720,7 +730,7 @@ void WindowBoundariesState::ValidEnd(DataChunk &bounds, idx_t row_idx, const idx
 			const auto valid_start = valid_begin_data[chunk_idx];
 			valid_end = partition_end_data[chunk_idx];
 
-			if ((valid_start < valid_end) && has_following_range) {
+			if (valid_start < valid_end) {
 				// Exclude any trailing NULLs
 				if (range->CellIsNull(0, valid_end - 1)) {
 					idx_t n = 1;

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

@@ -143,4 +143,34 @@ WindowCursor::WindowCursor(const WindowCollection &paged, column_t col_idx)
     : WindowCursor(paged, vector<column_t>(1, col_idx)) {
 }
 
+LogicalType WindowCollectionChunkScanner::PrefixStructType(column_t end, column_t begin) {
+	child_list_t<LogicalType> partition_children;
+	for (auto c = begin; c < end; ++c) {
+		auto name = std::to_string(c);
+		auto type = chunk.data[c].GetType();
+		std::pair<string, LogicalType> child {name, type};
+		partition_children.emplace_back(child);
+	}
+	//	For single children, don;t build a struct - compare will be slow
+	if (partition_children.size() == 1) {
+		return partition_children[0].second;
+	}
+	return LogicalType::STRUCT(partition_children);
+}
+
+void WindowCollectionChunkScanner::ReferenceStructColumns(DataChunk &chunk, Vector &vec, column_t end, column_t begin) {
+	//	Check for single column
+	const auto width = end - begin;
+	if (width == 1) {
+		vec.Reference(chunk.data[begin]);
+		return;
+	}
+
+	auto &entries = StructVector::GetEntries(vec);
+	D_ASSERT(width == entries.size());
+	for (column_t i = 0; i < entries.size(); ++i) {
+		entries[i]->Reference(chunk.data[begin + i]);
+	}
+}
+
 } // namespace duckdb