duckdb 0.7.2-dev2366.0 → 0.7.2-dev2430.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev2366.0",
+  "version": "0.7.2-dev2430.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -61,6 +61,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "PIECEWISE_MERGE_JOIN";
 	case PhysicalOperatorType::IE_JOIN:
 		return "IE_JOIN";
+	case PhysicalOperatorType::ASOF_JOIN:
+		return "ASOF_JOIN";
 	case PhysicalOperatorType::CROSS_PRODUCT:
 		return "CROSS_PRODUCT";
 	case PhysicalOperatorType::POSITIONAL_JOIN:

package/src/duckdb/src/common/file_buffer.cpp

@@ -97,4 +97,12 @@ void FileBuffer::Clear() {
 	memset(internal_buffer, 0, internal_size);
 }
 
+void FileBuffer::Initialize(DebugInitialize initialize) {
+	if (initialize == DebugInitialize::NO_INITIALIZE) {
+		return;
+	}
+	uint8_t value = initialize == DebugInitialize::DEBUG_ZERO_INITIALIZE ? 0 : 0xFF;
+	memset(internal_buffer, value, internal_size);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -60,6 +60,40 @@ idx_t RadixPartitioning::Select(Vector &hashes, const SelectionVector *sel, idx_
 	return RadixBitsSwitch<SelectFunctor, idx_t>(radix_bits, hashes, sel, count, cutoff, true_sel, false_sel);
 }
 
+struct HashsToBinsFunctor {
+	template <idx_t radix_bits>
+	static void Operation(Vector &hashes, Vector &bins, idx_t count) {
+		using CONSTANTS = RadixPartitioningConstants<radix_bits>;
+		UnaryExecutor::Execute<hash_t, hash_t>(hashes, bins, count,
+		                                       [&](hash_t hash) { return CONSTANTS::ApplyMask(hash); });
+	}
+};
+
+void RadixPartitioning::HashesToBins(Vector &hashes, idx_t radix_bits, Vector &bins, idx_t count) {
+	return RadixBitsSwitch<HashsToBinsFunctor, void>(radix_bits, hashes, bins, count);
+}
+
+//===--------------------------------------------------------------------===//
+// Row Data Partitioning
+//===--------------------------------------------------------------------===//
+template <idx_t radix_bits>
+static void InitPartitions(BufferManager &buffer_manager, vector<unique_ptr<RowDataCollection>> &partition_collections,
+                           RowDataBlock *partition_blocks[], vector<BufferHandle> &partition_handles,
+                           data_ptr_t partition_ptrs[], idx_t block_capacity, idx_t row_width) {
+	using CONSTANTS = RadixPartitioningConstants<radix_bits>;
+
+	partition_collections.reserve(CONSTANTS::NUM_PARTITIONS);
+	partition_handles.reserve(CONSTANTS::NUM_PARTITIONS);
+	for (idx_t i = 0; i < CONSTANTS::NUM_PARTITIONS; i++) {
+		partition_collections.push_back(make_uniq<RowDataCollection>(buffer_manager, block_capacity, row_width));
+		partition_blocks[i] = &partition_collections[i]->CreateBlock();
+		partition_handles.push_back(buffer_manager.Pin(partition_blocks[i]->block));
+		if (partition_ptrs) {
+			partition_ptrs[i] = partition_handles[i].Ptr();
+		}
+	}
+}
+
 struct ComputePartitionIndicesFunctor {
 	template <idx_t radix_bits>
 	static void Operation(Vector &hashes, Vector &partition_indices, idx_t count) {

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -18,15 +18,24 @@ PartitionGlobalHashGroup::PartitionGlobalHashGroup(BufferManager &buffer_manager
 	global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
 	global_sort->external = external;
 
+	//	Set up a comparator for the partition subset
 	partition_layout = global_sort->sort_layout.GetPrefixComparisonLayout(partitions.size());
 }
 
+int PartitionGlobalHashGroup::ComparePartitions(const SBIterator &left, const SBIterator &right) const {
+	int part_cmp = 0;
+	if (partition_layout.all_constant) {
+		part_cmp = FastMemcmp(left.entry_ptr, right.entry_ptr, partition_layout.comparison_size);
+	} else {
+		part_cmp = Comparators::CompareTuple(left.scan, right.scan, left.entry_ptr, right.entry_ptr, partition_layout,
+		                                     left.external);
+	}
+	return part_cmp;
+}
+
 void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask) {
 	D_ASSERT(count > 0);
 
-	//	Set up a comparator for the partition subset
-	const auto partition_size = partition_layout.comparison_size;
-
 	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
 	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
 
@@ -34,13 +43,8 @@ void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, Validi
 	order_mask.SetValidUnsafe(0);
 	for (++curr; curr.GetIndex() < count; ++curr) {
 		//	Compare the partition subset first because if that differs, then so does the full ordering
-		int part_cmp = 0;
-		if (partition_layout.all_constant) {
-			part_cmp = FastMemcmp(prev.entry_ptr, curr.entry_ptr, partition_size);
-		} else {
-			part_cmp = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, partition_layout,
-			                                     prev.external);
-		}
+		const auto part_cmp = ComparePartitions(prev, curr);
+		;
 
 		if (part_cmp) {
 			partition_mask.SetValidUnsafe(curr.GetIndex());
@@ -52,31 +56,40 @@ void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, Validi
 	}
 }
 
-PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
-                                                   const vector<unique_ptr<Expression>> &partitions_p,
-                                                   const vector<BoundOrderByNode> &orders_p, const Types &payload_types,
-                                                   const vector<unique_ptr<BaseStatistics>> &partitions_stats,
-                                                   idx_t estimated_cardinality)
-    : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
-      payload_types(payload_types), memory_per_thread(0), count(0) {
+void PartitionGlobalSinkState::GenerateOrderings(Orders &partitions, Orders &orders,
+                                                 const vector<unique_ptr<Expression>> &partition_bys,
+                                                 const Orders &order_bys,
+                                                 const vector<unique_ptr<BaseStatistics>> &partition_stats) {
 
 	// we sort by both 1) partition by expression list and 2) order by expressions
-	const auto partition_cols = partitions_p.size();
+	const auto partition_cols = partition_bys.size();
 	for (idx_t prt_idx = 0; prt_idx < partition_cols; prt_idx++) {
-		auto &pexpr = partitions_p[prt_idx];
+		auto &pexpr = partition_bys[prt_idx];
 
-		if (partitions_stats.empty() || !partitions_stats[prt_idx]) {
+		if (partition_stats.empty() || !partition_stats[prt_idx]) {
 			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(), nullptr);
 		} else {
 			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
-			                    partitions_stats[prt_idx]->ToUnique());
+			                    partition_stats[prt_idx]->ToUnique());
 		}
 		partitions.emplace_back(orders.back().Copy());
 	}
 
-	for (const auto &order : orders_p) {
+	for (const auto &order : order_bys) {
 		orders.emplace_back(order.Copy());
 	}
+}
+
+PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
+                                                   const vector<unique_ptr<Expression>> &partition_bys,
+                                                   const vector<BoundOrderByNode> &order_bys,
+                                                   const Types &payload_types,
+                                                   const vector<unique_ptr<BaseStatistics>> &partition_stats,
+                                                   idx_t estimated_cardinality)
+    : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
+      payload_types(payload_types), memory_per_thread(0), count(0) {
+
+	GenerateOrderings(partitions, orders, partition_bys, order_bys, partition_stats);
 
 	memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
 	external = ClientConfig::GetConfig(context).force_external;
@@ -337,7 +350,8 @@ void PartitionLocalSinkState::Combine() {
 	gstate.CombineLocalPartition(local_partition, local_append);
 }
 
-PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data)
+PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data,
+                                                     hash_t hash_bin)
     : sink(sink), group_data(std::move(group_data)), stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0),
       tasks_completed(0) {
 
@@ -348,6 +362,8 @@ PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &s
 
 	hash_group = sink.hash_groups[group_idx].get();
 	global_sort = sink.hash_groups[group_idx]->global_sort.get();
+
+	sink.bin_groups[hash_bin] = group_idx;
 }
 
 void PartitionLocalMergeState::Prepare() {
@@ -445,10 +461,13 @@ bool PartitionGlobalMergeState::TryPrepareNextStage() {
 
 PartitionGlobalMergeStates::PartitionGlobalMergeStates(PartitionGlobalSinkState &sink) {
 	// Schedule all the sorts for maximum thread utilisation
-	for (auto &group_data : sink.grouping_data->GetPartitions()) {
+	auto &partitions = sink.grouping_data->GetPartitions();
+	sink.bin_groups.resize(partitions.size(), partitions.size());
+	for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
+		auto &group_data = partitions[hash_bin];
 		// Prepare for merge sort phase
 		if (group_data->Count()) {
-			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data));
+			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
 			states.emplace_back(std::move(state));
 		}
 	}
@@ -542,103 +561,4 @@ void PartitionMergeEvent::Schedule() {
 	SetTasks(std::move(merge_tasks));
 }
 
-PartitionLocalSourceState::PartitionLocalSourceState(PartitionGlobalSinkState &gstate_p) : gstate(gstate_p) {
-	const auto &input_types = gstate.payload_types;
-	layout.Initialize(input_types);
-	input_chunk.Initialize(gstate.allocator, input_types);
-}
-
-void PartitionLocalSourceState::MaterializeSortedData() {
-	auto &global_sort_state = *hash_group->global_sort;
-	if (global_sort_state.sorted_blocks.empty()) {
-		return;
-	}
-
-	// scan the sorted row data
-	D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-	auto &sb = *global_sort_state.sorted_blocks[0];
-
-	// Free up some memory before allocating more
-	sb.radix_sorting_data.clear();
-	sb.blob_sorting_data = nullptr;
-
-	// Move the sorting row blocks into our RDCs
-	auto &buffer_manager = global_sort_state.buffer_manager;
-	auto &sd = *sb.payload_data;
-
-	// Data blocks are required
-	D_ASSERT(!sd.data_blocks.empty());
-	auto &block = sd.data_blocks[0];
-	rows = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-	rows->blocks = std::move(sd.data_blocks);
-	rows->count = std::accumulate(rows->blocks.begin(), rows->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-
-	// Heap blocks are optional, but we want both for iteration.
-	if (!sd.heap_blocks.empty()) {
-		auto &block = sd.heap_blocks[0];
-		heap = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-		heap->blocks = std::move(sd.heap_blocks);
-		hash_group.reset();
-	} else {
-		heap = make_uniq<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-	}
-	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-}
-
-idx_t PartitionLocalSourceState::GeneratePartition(const idx_t hash_bin_p) {
-	//	Get rid of any stale data
-	hash_bin = hash_bin_p;
-
-	// There are three types of partitions:
-	// 1. No partition (no sorting)
-	// 2. One partition (sorting, but no hashing)
-	// 3. Multiple partitions (sorting and hashing)
-
-	//	How big is the partition?
-	idx_t count = 0;
-	if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
-		count = gstate.hash_groups[hash_bin]->count;
-	} else if (gstate.rows && !hash_bin) {
-		count = gstate.count;
-	} else {
-		return count;
-	}
-
-	//	Initialise masks to false
-	const auto bit_count = ValidityMask::ValidityMaskSize(count);
-	partition_bits.clear();
-	partition_bits.resize(bit_count, 0);
-	partition_mask.Initialize(partition_bits.data());
-
-	order_bits.clear();
-	order_bits.resize(bit_count, 0);
-	order_mask.Initialize(order_bits.data());
-
-	// Scan the sorted data into new Collections
-	auto external = gstate.external;
-	if (gstate.rows && !hash_bin) {
-		// Simple mask
-		partition_mask.SetValidUnsafe(0);
-		order_mask.SetValidUnsafe(0);
-		//	No partition - align the heap blocks with the row blocks
-		rows = gstate.rows->CloneEmpty(gstate.rows->keep_pinned);
-		heap = gstate.strings->CloneEmpty(gstate.strings->keep_pinned);
-		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gstate.rows, *gstate.strings, layout);
-		external = true;
-	} else if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
-		// Overwrite the collections with the sorted data
-		hash_group = std::move(gstate.hash_groups[hash_bin]);
-		hash_group->ComputeMasks(partition_mask, order_mask);
-		MaterializeSortedData();
-	} else {
-		return count;
-	}
-
-	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
-
-	return count;
-}
-
 } // namespace duckdb

package/src/duckdb/src/common/sort/sorted_block.cpp

@@ -367,7 +367,7 @@ int SBIterator::ComparisonValue(ExpressionType comparison) {
 }
 
 static idx_t GetBlockCountWithEmptyCheck(const GlobalSortState &gss) {
-	D_ASSERT(gss.sorted_blocks.size() > 0);
+	D_ASSERT(!gss.sorted_blocks.empty());
 	return gss.sorted_blocks[0]->radix_sorting_data.size();
 }
 

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1093,14 +1093,26 @@ SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 class WindowGlobalSourceState : public GlobalSourceState {
 public:
-	explicit WindowGlobalSourceState(WindowGlobalSinkState &gsink) : partition_source(*gsink.global_partition) {
+	explicit WindowGlobalSourceState(WindowGlobalSinkState &gsink) : gsink(*gsink.global_partition), next_bin(0) {
 	}
 
-	PartitionGlobalSourceState partition_source;
+	PartitionGlobalSinkState &gsink;
+	//! The output read position.
+	atomic<idx_t> next_bin;
 
 public:
 	idx_t MaxThreads() override {
-		return partition_source.MaxThreads();
+		// If there is only one partition, we have to process it on one thread.
+		if (!gsink.grouping_data) {
+			return 1;
+		}
+
+		// If there is not a lot of data, process serially.
+		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
+			return 1;
+		}
+
+		return gsink.hash_groups.size();
 	}
 };
 
@@ -1112,7 +1124,7 @@ public:
 	using WindowExecutors = vector<WindowExecutorPtr>;
 
 	WindowLocalSourceState(const PhysicalWindow &op_p, ExecutionContext &context, WindowGlobalSourceState &gsource)
-	    : partition_source(gsource.partition_source.gsink), context(context.client), op(op_p) {
+	    : context(context.client), op(op_p), gsink(gsource.gsink) {
 
 		vector<LogicalType> output_types;
 		for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
@@ -1121,29 +1133,134 @@ public:
 			output_types.emplace_back(wexpr.return_type);
 		}
 		output_chunk.Initialize(Allocator::Get(context.client), output_types);
+
+		const auto &input_types = gsink.payload_types;
+		layout.Initialize(input_types);
+		input_chunk.Initialize(gsink.allocator, input_types);
 	}
 
+	void MaterializeSortedData();
 	void GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin);
 	void Scan(DataChunk &chunk);
 
-	PartitionLocalSourceState partition_source;
+	HashGroupPtr hash_group;
 	ClientContext &context;
 	const PhysicalWindow &op;
 
+	PartitionGlobalSinkState &gsink;
+
+	//! The generated input chunks
+	unique_ptr<RowDataCollection> rows;
+	unique_ptr<RowDataCollection> heap;
+	RowLayout layout;
+	//! The partition boundary mask
+	vector<validity_t> partition_bits;
+	ValidityMask partition_mask;
+	//! The order boundary mask
+	vector<validity_t> order_bits;
+	ValidityMask order_mask;
 	//! The current execution functions
 	WindowExecutors window_execs;
+
+	//! The read partition
+	idx_t hash_bin;
+	//! The read cursor
+	unique_ptr<RowDataCollectionScanner> scanner;
+	//! Buffer for the inputs
+	DataChunk input_chunk;
 	//! Buffer for window results
 	DataChunk output_chunk;
 };
 
+void WindowLocalSourceState::MaterializeSortedData() {
+	auto &global_sort_state = *hash_group->global_sort;
+	if (global_sort_state.sorted_blocks.empty()) {
+		return;
+	}
+
+	// scan the sorted row data
+	D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
+	auto &sb = *global_sort_state.sorted_blocks[0];
+
+	// Free up some memory before allocating more
+	sb.radix_sorting_data.clear();
+	sb.blob_sorting_data = nullptr;
+
+	// Move the sorting row blocks into our RDCs
+	auto &buffer_manager = global_sort_state.buffer_manager;
+	auto &sd = *sb.payload_data;
+
+	// Data blocks are required
+	D_ASSERT(!sd.data_blocks.empty());
+	auto &block = sd.data_blocks[0];
+	rows = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
+	rows->blocks = std::move(sd.data_blocks);
+	rows->count = std::accumulate(rows->blocks.begin(), rows->blocks.end(), idx_t(0),
+	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
+
+	// Heap blocks are optional, but we want both for iteration.
+	if (!sd.heap_blocks.empty()) {
+		auto &block = sd.heap_blocks[0];
+		heap = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
+		heap->blocks = std::move(sd.heap_blocks);
+		hash_group.reset();
+	} else {
+		heap = make_uniq<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
+	}
+	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
+	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
+}
+
 void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
-	const auto count = partition_source.GeneratePartition(hash_bin_p);
-	if (!count) {
+	//	Get rid of any stale data
+	hash_bin = hash_bin_p;
+
+	// There are three types of partitions:
+	// 1. No partition (no sorting)
+	// 2. One partition (sorting, but no hashing)
+	// 3. Multiple partitions (sorting and hashing)
+
+	//	How big is the partition?
+	idx_t count = 0;
+	if (hash_bin < gsink.hash_groups.size() && gsink.hash_groups[hash_bin]) {
+		count = gsink.hash_groups[hash_bin]->count;
+	} else if (gsink.rows && !hash_bin) {
+		count = gsink.count;
+	} else {
+		return;
+	}
+
+	//	Initialise masks to false
+	const auto bit_count = ValidityMask::ValidityMaskSize(count);
+	partition_bits.clear();
+	partition_bits.resize(bit_count, 0);
+	partition_mask.Initialize(partition_bits.data());
+
+	order_bits.clear();
+	order_bits.resize(bit_count, 0);
+	order_mask.Initialize(order_bits.data());
+
+	// Scan the sorted data into new Collections
+	auto external = gsink.external;
+	if (gsink.rows && !hash_bin) {
+		// Simple mask
+		partition_mask.SetValidUnsafe(0);
+		order_mask.SetValidUnsafe(0);
+		//	No partition - align the heap blocks with the row blocks
+		rows = gsink.rows->CloneEmpty(gsink.rows->keep_pinned);
+		heap = gsink.strings->CloneEmpty(gsink.strings->keep_pinned);
+		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gsink.rows, *gsink.strings, layout);
+		external = true;
+	} else if (hash_bin < gsink.hash_groups.size() && gsink.hash_groups[hash_bin]) {
+		// Overwrite the collections with the sorted data
+		hash_group = std::move(gsink.hash_groups[hash_bin]);
+		hash_group->ComputeMasks(partition_mask, order_mask);
+		MaterializeSortedData();
+	} else {
 		return;
 	}
 
 	// Create the executors for each function
-	auto &partition_mask = partition_source.partition_mask;
 	window_execs.clear();
 	for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
 		D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
@@ -1154,19 +1271,20 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 
 	//	First pass over the input without flushing
 	//	TODO: Factor out the constructor data as global state
+	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
 	idx_t input_idx = 0;
 	while (true) {
-		partition_source.input_chunk.Reset();
-		partition_source.scanner->Scan(partition_source.input_chunk);
-		if (partition_source.input_chunk.size() == 0) {
+		input_chunk.Reset();
+		scanner->Scan(input_chunk);
+		if (input_chunk.size() == 0) {
 			break;
 		}
 
 		//	TODO: Parallelization opportunity
 		for (auto &wexec : window_execs) {
-			wexec->Sink(partition_source.input_chunk, input_idx, partition_source.scanner->Count());
+			wexec->Sink(input_chunk, input_idx, scanner->Count());
 		}
-		input_idx += partition_source.input_chunk.size();
+		input_idx += input_chunk.size();
 	}
 
 	//	TODO: Parallelization opportunity
@@ -1175,25 +1293,22 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	}
 
 	// External scanning assumes all blocks are swizzled.
-	partition_source.scanner->ReSwizzle();
+	scanner->ReSwizzle();
 
 	//	Second pass can flush
-	partition_source.scanner->Reset(true);
+	scanner->Reset(true);
 }
 
 void WindowLocalSourceState::Scan(DataChunk &result) {
-	D_ASSERT(partition_source.scanner);
-	if (!partition_source.scanner->Remaining()) {
+	D_ASSERT(scanner);
+	if (!scanner->Remaining()) {
 		return;
 	}
 
-	const auto position = partition_source.scanner->Scanned();
-	auto &input_chunk = partition_source.input_chunk;
+	const auto position = scanner->Scanned();
 	input_chunk.Reset();
-	partition_source.scanner->Scan(input_chunk);
+	scanner->Scan(input_chunk);
 
-	auto &partition_mask = partition_source.partition_mask;
-	auto &order_mask = partition_source.order_mask;
 	output_chunk.Reset();
 	for (idx_t expr_idx = 0; expr_idx < window_execs.size(); ++expr_idx) {
 		auto &executor = *window_execs[expr_idx];
@@ -1227,9 +1342,7 @@ unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext
 void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                              LocalSourceState &lstate_p) const {
 	auto &lsource = lstate_p.Cast<WindowLocalSourceState>();
-	auto &lpsource = lsource.partition_source;
 	auto &gsource = gstate_p.Cast<WindowGlobalSourceState>();
-	auto &gpsource = gsource.partition_source;
 	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
 
 	auto &hash_groups = gsink.global_partition->hash_groups;
@@ -1237,17 +1350,17 @@ void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, Global
 
 	while (chunk.size() == 0) {
 		//	Move to the next bin if we are done.
-		while (!lpsource.scanner || !lpsource.scanner->Remaining()) {
-			lpsource.scanner.reset();
-			lpsource.rows.reset();
-			lpsource.heap.reset();
-			lpsource.hash_group.reset();
-			auto hash_bin = gpsource.next_bin++;
+		while (!lsource.scanner || !lsource.scanner->Remaining()) {
+			lsource.scanner.reset();
+			lsource.rows.reset();
+			lsource.heap.reset();
+			lsource.hash_group.reset();
+			auto hash_bin = gsource.next_bin++;
 			if (hash_bin >= bin_count) {
 				return;
 			}
 
-			for (; hash_bin < hash_groups.size(); hash_bin = gpsource.next_bin++) {
+			for (; hash_bin < hash_groups.size(); hash_bin = gsource.next_bin++) {
 				if (hash_groups[hash_bin]) {
 					break;
 				}