duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

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

@@ -33,7 +33,7 @@ namespace duckdb {
 class WindowGlobalSinkState : public GlobalSinkState {
 public:
 	WindowGlobalSinkState(const PhysicalWindow &op, ClientContext &context)
-	    : mode(DBConfig::GetConfig(context).options.window_mode) {
+	    : op(op), mode(DBConfig::GetConfig(context).options.window_mode) {
 
 		D_ASSERT(op.select_list[0]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
 		auto &wexpr = op.select_list[0]->Cast<BoundWindowExpression>();
@@ -43,6 +43,7 @@ public:
 		                                        wexpr.partitions_stats, op.estimated_cardinality);
 	}
 
+	const PhysicalWindow &op;
 	unique_ptr<PartitionGlobalSinkState> global_partition;
 	WindowAggregationMode mode;
 };
@@ -172,66 +173,93 @@ SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
+class WindowPartitionSourceState;
+
 class WindowGlobalSourceState : public GlobalSourceState {
 public:
-	explicit WindowGlobalSourceState(WindowGlobalSinkState &gsink) : gsink(*gsink.global_partition), next_bin(0) {
-	}
+	using HashGroupSourcePtr = unique_ptr<WindowPartitionSourceState>;
+	using ScannerPtr = unique_ptr<RowDataCollectionScanner>;
+	using Task = std::pair<WindowPartitionSourceState *, ScannerPtr>;
+
+	WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p);
 
-	PartitionGlobalSinkState &gsink;
-	//! The output read position.
-	atomic<idx_t> next_bin;
+	//! Get the next task
+	Task NextTask(idx_t hash_bin);
+
+	//! Context for executing computations
+	ClientContext &context;
+	//! All the sunk data
+	WindowGlobalSinkState &gsink;
+	//! The next group to build.
+	atomic<idx_t> next_build;
+	//! The built groups
+	vector<HashGroupSourcePtr> built;
+	//! Serialise access to the built hash groups
+	mutable mutex built_lock;
+	//! The number of unfinished tasks
+	atomic<idx_t> tasks_remaining;
 
 public:
 	idx_t MaxThreads() override {
-		// If there is only one partition, we have to process it on one thread.
-		if (!gsink.grouping_data) {
-			return 1;
-		}
+		return tasks_remaining;
+	}
+
+private:
+	Task CreateTask(idx_t hash_bin);
+	Task StealWork();
+};
 
-		// If there is not a lot of data, process serially.
-		if (gsink.count < STANDARD_ROW_GROUPS_SIZE) {
-			return 1;
+WindowGlobalSourceState::WindowGlobalSourceState(ClientContext &context_p, WindowGlobalSinkState &gsink_p)
+    : context(context_p), gsink(gsink_p), next_build(0), tasks_remaining(0) {
+	auto &hash_groups = gsink.global_partition->hash_groups;
+
+	auto &gpart = gsink.global_partition;
+	if (hash_groups.empty()) {
+		//	OVER()
+		built.resize(1);
+		if (gpart->rows) {
+			tasks_remaining += gpart->rows->blocks.size();
 		}
+	} else {
+		built.resize(hash_groups.size());
+		for (auto &hash_group : hash_groups) {
+			if (!hash_group) {
+				continue;
+			}
+			auto &global_sort_state = *hash_group->global_sort;
+			if (global_sort_state.sorted_blocks.empty()) {
+				continue;
+			}
 
-		return gsink.hash_groups.size();
+			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
+			auto &sb = *global_sort_state.sorted_blocks[0];
+			auto &sd = *sb.payload_data;
+			tasks_remaining += sd.data_blocks.size();
+		}
 	}
-};
+}
 
-// Per-thread read state
-class WindowLocalSourceState : public LocalSourceState {
+// Per-bin evaluation state (build and evaluate)
+class WindowPartitionSourceState {
 public:
 	using HashGroupPtr = unique_ptr<PartitionGlobalHashGroup>;
 	using ExecutorPtr = unique_ptr<WindowExecutor>;
 	using Executors = vector<ExecutorPtr>;
-	using LocalStatePtr = unique_ptr<WindowExecutorState>;
-	using LocalStates = vector<LocalStatePtr>;
-
-	WindowLocalSourceState(const PhysicalWindow &op_p, ExecutionContext &context, WindowGlobalSourceState &gsource)
-	    : 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) {
-			D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto &wexpr = op.select_list[expr_idx]->Cast<BoundWindowExpression>();
-			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);
+	WindowPartitionSourceState(ClientContext &context, WindowGlobalSourceState &gsource)
+	    : context(context), op(gsource.gsink.op), gsource(gsource), read_block_idx(0), unscanned(0) {
+		layout.Initialize(gsource.gsink.global_partition->payload_types);
 	}
 
+	unique_ptr<RowDataCollectionScanner> GetScanner() const;
 	void MaterializeSortedData();
-	void GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin);
-	void Scan(DataChunk &chunk);
+	void BuildPartition(WindowGlobalSinkState &gstate, const idx_t hash_bin);
 
-	HashGroupPtr hash_group;
 	ClientContext &context;
 	const PhysicalWindow &op;
+	WindowGlobalSourceState &gsource;
 
-	PartitionGlobalSinkState &gsink;
-
+	HashGroupPtr hash_group;
 	//! The generated input chunks
 	unique_ptr<RowDataCollection> rows;
 	unique_ptr<RowDataCollection> heap;
@@ -242,21 +270,21 @@ public:
 	//! The order boundary mask
 	vector<validity_t> order_bits;
 	ValidityMask order_mask;
+	//! External paging
+	bool external;
 	//! The current execution functions
 	Executors executors;
-	LocalStates local_states;
 
-	//! The read partition
+	//! The bin number
 	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;
+
+	//! The next block to read.
+	mutable atomic<idx_t> read_block_idx;
+	//! The number of remaining unscanned blocks.
+	atomic<idx_t> unscanned;
 };
 
-void WindowLocalSourceState::MaterializeSortedData() {
+void WindowPartitionSourceState::MaterializeSortedData() {
 	auto &global_sort_state = *hash_group->global_sort;
 	if (global_sort_state.sorted_blocks.empty()) {
 		return;
@@ -295,7 +323,21 @@ void WindowLocalSourceState::MaterializeSortedData() {
 	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
 }
 
-void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
+unique_ptr<RowDataCollectionScanner> WindowPartitionSourceState::GetScanner() const {
+	auto &gsink = *gsource.gsink.global_partition;
+	if ((gsink.rows && !hash_bin) || hash_bin < gsink.hash_groups.size()) {
+		const auto block_idx = read_block_idx++;
+		if (block_idx >= rows->blocks.size()) {
+			return nullptr;
+		}
+		//	Second pass can flush
+		--gsource.tasks_remaining;
+		return make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, block_idx, true);
+	}
+	return nullptr;
+}
+
+void WindowPartitionSourceState::BuildPartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
 	//	Get rid of any stale data
 	hash_bin = hash_bin_p;
 
@@ -305,11 +347,12 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	// 3. Multiple partitions (sorting and hashing)
 
 	//	How big is the partition?
+	auto &gpart = *gsource.gsink.global_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;
+	if (hash_bin < gpart.hash_groups.size() && gpart.hash_groups[hash_bin]) {
+		count = gpart.hash_groups[hash_bin]->count;
+	} else if (gpart.rows && !hash_bin) {
+		count = gpart.count;
 	} else {
 		return;
 	}
@@ -325,19 +368,20 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	order_mask.Initialize(order_bits.data());
 
 	// Scan the sorted data into new Collections
-	auto external = gsink.external;
-	if (gsink.rows && !hash_bin) {
+	external = gpart.external;
+	if (gpart.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);
+		rows = gpart.rows->CloneEmpty(gpart.rows->keep_pinned);
+		heap = gpart.strings->CloneEmpty(gpart.strings->keep_pinned);
+		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gpart.rows, *gpart.strings, layout);
 		external = true;
-	} else if (hash_bin < gsink.hash_groups.size() && gsink.hash_groups[hash_bin]) {
+	} else if (hash_bin < gpart.hash_groups.size()) {
 		// Overwrite the collections with the sorted data
-		hash_group = std::move(gsink.hash_groups[hash_bin]);
+		D_ASSERT(gpart.hash_groups[hash_bin].get());
+		hash_group = std::move(gpart.hash_groups[hash_bin]);
 		hash_group->ComputeMasks(partition_mask, order_mask);
 		external = hash_group->global_sort->external;
 		MaterializeSortedData();
@@ -346,7 +390,6 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	}
 
 	// Create the executors for each function
-	local_states.clear();
 	executors.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);
@@ -356,8 +399,9 @@ 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);
+	DataChunk input_chunk;
+	input_chunk.Initialize(gpart.allocator, gpart.payload_types);
+	auto scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
 	idx_t input_idx = 0;
 	while (true) {
 		input_chunk.Reset();
@@ -376,30 +420,196 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	//	TODO: Parallelization opportunity
 	for (auto &wexec : executors) {
 		wexec->Finalize();
-		local_states.emplace_back(wexec->GetExecutorState());
 	}
 
 	// External scanning assumes all blocks are swizzled.
 	scanner->ReSwizzle();
 
-	//	Second pass can flush
-	scanner->Reset(true);
+	//	Start the block countdown
+	unscanned = rows->blocks.size();
+}
+
+// Per-thread scan state
+class WindowLocalSourceState : public LocalSourceState {
+public:
+	using ReadStatePtr = unique_ptr<WindowExecutorState>;
+	using ReadStates = vector<ReadStatePtr>;
+
+	explicit WindowLocalSourceState(WindowGlobalSourceState &gsource);
+	bool NextPartition();
+	void Scan(DataChunk &chunk);
+
+	//! The shared source state
+	WindowGlobalSourceState &gsource;
+	//! The current bin being processed
+	idx_t hash_bin;
+	//! The current source being processed
+	optional_ptr<WindowPartitionSourceState> partition_source;
+	//! The read cursor
+	unique_ptr<RowDataCollectionScanner> scanner;
+	//! Buffer for the inputs
+	DataChunk input_chunk;
+	//! Executor read states.
+	ReadStates read_states;
+	//! Buffer for window results
+	DataChunk output_chunk;
+};
+
+WindowLocalSourceState::WindowLocalSourceState(WindowGlobalSourceState &gsource)
+    : gsource(gsource), hash_bin(gsource.built.size()) {
+	auto &gsink = *gsource.gsink.global_partition;
+	auto &op = gsource.gsink.op;
+
+	input_chunk.Initialize(gsink.allocator, gsink.payload_types);
+
+	vector<LogicalType> output_types;
+	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);
+		auto &wexpr = op.select_list[expr_idx]->Cast<BoundWindowExpression>();
+		output_types.emplace_back(wexpr.return_type);
+	}
+	output_chunk.Initialize(Allocator::Get(gsource.context), output_types);
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::CreateTask(idx_t hash_bin) {
+	//	Build outside the lock so no one tries to steal before we are done.
+	auto partition_source = make_uniq<WindowPartitionSourceState>(context, *this);
+	partition_source->BuildPartition(gsink, hash_bin);
+	Task result(partition_source.get(), partition_source->GetScanner());
+
+	//	Is there any data to scan?
+	if (result.second) {
+		lock_guard<mutex> built_guard(built_lock);
+		built[hash_bin] = std::move(partition_source);
+
+		return result;
+	}
+
+	return Task();
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::StealWork() {
+	for (idx_t hash_bin = 0; hash_bin < built.size(); ++hash_bin) {
+		lock_guard<mutex> built_guard(built_lock);
+		auto &partition_source = built[hash_bin];
+		if (!partition_source) {
+			continue;
+		}
+
+		Task result(partition_source.get(), partition_source->GetScanner());
+
+		//	Is there any data to scan?
+		if (result.second) {
+			return result;
+		}
+	}
+
+	//	Nothing to steal
+	return Task();
+}
+
+WindowGlobalSourceState::Task WindowGlobalSourceState::NextTask(idx_t hash_bin) {
+	auto &hash_groups = gsink.global_partition->hash_groups;
+	const auto bin_count = built.size();
+
+	//	Flush unneeded data
+	if (hash_bin < bin_count) {
+		//	Lock and delete when all blocks have been scanned
+		//	We do this here instead of in NextScan so the WindowLocalSourceState
+		//	has a chance to delete its state objects first,
+		//	which may reference the partition_source
+
+		//	Delete data outside the lock in case it is slow
+		HashGroupSourcePtr killed;
+		lock_guard<mutex> built_guard(built_lock);
+		auto &partition_source = built[hash_bin];
+		if (partition_source && !partition_source->unscanned) {
+			killed = std::move(partition_source);
+		}
+	}
+
+	hash_bin = next_build++;
+	if (hash_bin < bin_count) {
+		//	Find a non-empty hash group.
+		for (; hash_bin < hash_groups.size(); hash_bin = next_build++) {
+			if (hash_groups[hash_bin]) {
+				auto result = CreateTask(hash_bin);
+				if (result.second) {
+					return result;
+				}
+			}
+		}
+
+		//	OVER() doesn't have a hash_group
+		if (hash_groups.empty()) {
+			auto result = CreateTask(hash_bin);
+			if (result.second) {
+				return result;
+			}
+		}
+	}
+
+	//	Work stealing
+	while (tasks_remaining) {
+		auto result = StealWork();
+		if (result.second) {
+			return result;
+		}
+
+		//	If there is nothing to steal but there are unfinished partitions,
+		//	yield until any pending builds are done.
+		TaskScheduler::GetScheduler(context).YieldThread();
+	}
+
+	return Task();
+}
+
+bool WindowLocalSourceState::NextPartition() {
+	//	Release old states before the source
+	scanner.reset();
+	read_states.clear();
+
+	//	Get a partition_source that is not finished
+	while (!scanner) {
+		auto task = gsource.NextTask(hash_bin);
+		if (!task.first) {
+			return false;
+		}
+		partition_source = task.first;
+		scanner = std::move(task.second);
+		hash_bin = partition_source->hash_bin;
+	}
+
+	for (auto &wexec : partition_source->executors) {
+		read_states.emplace_back(wexec->GetExecutorState());
+	}
+
+	return true;
 }
 
 void WindowLocalSourceState::Scan(DataChunk &result) {
 	D_ASSERT(scanner);
 	if (!scanner->Remaining()) {
-		return;
+		lock_guard<mutex> built_guard(gsource.built_lock);
+		--partition_source->unscanned;
+		scanner = partition_source->GetScanner();
+
+		if (!scanner) {
+			partition_source = nullptr;
+			read_states.clear();
+			return;
+		}
 	}
 
 	const auto position = scanner->Scanned();
 	input_chunk.Reset();
 	scanner->Scan(input_chunk);
 
+	auto &executors = partition_source->executors;
 	output_chunk.Reset();
 	for (idx_t expr_idx = 0; expr_idx < executors.size(); ++expr_idx) {
 		auto &executor = *executors[expr_idx];
-		auto &lstate = *local_states[expr_idx];
+		auto &lstate = *read_states[expr_idx];
 		auto &result = output_chunk.data[expr_idx];
 		executor.Evaluate(position, input_chunk, result, lstate);
 	}
@@ -418,43 +628,25 @@ void WindowLocalSourceState::Scan(DataChunk &result) {
 }
 
 unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContext &context,
-                                                                 GlobalSourceState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<WindowGlobalSourceState>();
-	return make_uniq<WindowLocalSourceState>(*this, context, gstate);
+                                                                 GlobalSourceState &gsource_p) const {
+	auto &gsource = gsource_p.Cast<WindowGlobalSourceState>();
+	return make_uniq<WindowLocalSourceState>(gsource);
 }
 
 unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext &context) const {
 	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-	return make_uniq<WindowGlobalSourceState>(gsink);
+	return make_uniq<WindowGlobalSourceState>(context, gsink);
 }
 
 SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
                                          OperatorSourceInput &input) const {
 	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
-	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
-	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
-
-	auto &hash_groups = gsink.global_partition->hash_groups;
-	const auto bin_count = hash_groups.empty() ? 1 : hash_groups.size();
-
 	while (chunk.size() == 0) {
 		//	Move to the next bin if we are done.
-		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) {
+		while (!lsource.scanner) {
+			if (!lsource.NextPartition()) {
 				return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
 			}
-
-			for (; hash_bin < hash_groups.size(); hash_bin = gsource.next_bin++) {
-				if (hash_groups[hash_bin]) {
-					break;
-				}
-			}
-			lsource.GeneratePartition(gsink, hash_bin);
 		}
 
 		lsource.Scan(chunk);

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -55,7 +55,7 @@ OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, Da
 string PhysicalFilter::ParamsToString() const {
 	auto result = expression->GetName();
 	result += "\n[INFOSEPARATOR]\n";
-	result += StringUtil::Format("EC: %llu", estimated_props->GetCardinality<idx_t>());
+	result += StringUtil::Format("EC: %llu", estimated_cardinality);
 	return result;
 }
 

package/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp

@@ -31,8 +31,7 @@ string PhysicalComparisonJoin::ParamsToString() const {
 		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
 	}
 	extra_info += "\n[INFOSEPARATOR]\n";
-	extra_info += StringUtil::Format("EC: %llu\n", estimated_props->GetCardinality<idx_t>());
-	extra_info += StringUtil::Format("Cost: %llu", estimated_props->GetCost<idx_t>());
+	extra_info += StringUtil::Format("EC: %llu\n", estimated_cardinality);
 	return extra_info;
 }
 

package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp

@@ -145,7 +145,7 @@ string PhysicalTableScan::ParamsToString() const {
 		result += "File Filters: " + extra_info.file_filters;
 	}
 	result += "\n[INFOSEPARATOR]\n";
-	result += StringUtil::Format("EC: %llu", estimated_props->GetCardinality<idx_t>());
+	result += StringUtil::Format("EC: %llu", estimated_cardinality);
 	return result;
 }
 

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -225,12 +225,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 		throw InternalException("Physical plan generator - no plan generated");
 	}
 
-	if (op.estimated_props) {
-		plan->estimated_cardinality = op.estimated_props->GetCardinality<idx_t>();
-		plan->estimated_props = op.estimated_props->Copy();
-	} else {
-		plan->estimated_props = make_uniq<EstimatedProperties>();
-	}
+	plan->estimated_cardinality = op.estimated_cardinality;
 
 	return plan;
 }

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

@@ -315,6 +315,7 @@ struct WindowBoundariesState {
 	const bool has_following_range;
 	const bool needs_peer;
 
+	idx_t next_pos = 0;
 	idx_t partition_start = 0;
 	idx_t partition_end = 0;
 	idx_t peer_start = 0;
@@ -339,12 +340,19 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		// determine partition and peer group boundaries to ultimately figure out window size
 		const auto is_same_partition = !partition_mask.RowIsValidUnsafe(row_idx);
 		const auto is_peer = !order_mask.RowIsValidUnsafe(row_idx);
+		const auto is_jump = (next_pos != row_idx);
 
 		// when the partition changes, recompute the boundaries
-		if (!is_same_partition) {
+		if (!is_same_partition || is_jump) {
 			partition_start = row_idx;
 			peer_start = row_idx;
 
+			if (is_jump) {
+				//	Go back as far as the previous partition start
+				idx_t n = 1;
+				partition_start = FindPrevStart(partition_mask, partition_start, row_idx + 1, n);
+			}
+
 			// find end of partition
 			partition_end = input_size;
 			if (partition_count) {
@@ -393,6 +401,7 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		partition_end = input_size;
 		peer_end = partition_end;
 	}
+	next_pos = row_idx + 1;
 
 	// determine window boundaries depending on the type of expression
 	window_start = -1;

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

@@ -1240,14 +1240,14 @@ static unique_ptr<FunctionData> CSVReaderDeserialize(PlanDeserializationState &s
 static void CSVReaderFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                      const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	serializer.WriteProperty("extra_info", function.extra_info);
-	serializer.WriteProperty("csv_data", bind_data);
+	serializer.WriteProperty(100, "extra_info", function.extra_info);
+	serializer.WriteProperty(101, "csv_data", bind_data);
 }
 
 static unique_ptr<FunctionData> CSVReaderFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
 	unique_ptr<ReadCSVData> result;
-	deserializer.ReadProperty("extra_info", function.extra_info);
-	deserializer.ReadProperty("csv_data", result);
+	deserializer.ReadProperty(100, "extra_info", function.extra_info);
+	deserializer.ReadProperty(101, "csv_data", result);
 	return std::move(result);
 }
 

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

@@ -452,29 +452,29 @@ static unique_ptr<FunctionData> TableScanDeserialize(PlanDeserializationState &s
 static void TableScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                      const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	serializer.WriteProperty("catalog", bind_data.table.schema.catalog.GetName());
-	serializer.WriteProperty("schema", bind_data.table.schema.name);
-	serializer.WriteProperty("table", bind_data.table.name);
-	serializer.WriteProperty("is_index_scan", bind_data.is_index_scan);
-	serializer.WriteProperty("is_create_index", bind_data.is_create_index);
-	serializer.WriteProperty("result_ids", bind_data.result_ids);
-	serializer.WriteProperty("result_ids", bind_data.result_ids);
+	serializer.WriteProperty(100, "catalog", bind_data.table.schema.catalog.GetName());
+	serializer.WriteProperty(101, "schema", bind_data.table.schema.name);
+	serializer.WriteProperty(102, "table", bind_data.table.name);
+	serializer.WriteProperty(103, "is_index_scan", bind_data.is_index_scan);
+	serializer.WriteProperty(104, "is_create_index", bind_data.is_create_index);
+	serializer.WriteProperty(105, "result_ids", bind_data.result_ids);
+	serializer.WriteProperty(106, "result_ids", bind_data.result_ids);
 }
 
 static unique_ptr<FunctionData> TableScanFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto table = deserializer.ReadProperty<string>("table");
+	auto catalog = deserializer.ReadProperty<string>(100, "catalog");
+	auto schema = deserializer.ReadProperty<string>(101, "schema");
+	auto table = deserializer.ReadProperty<string>(102, "table");
 	auto &catalog_entry =
 	    Catalog::GetEntry<TableCatalogEntry>(deserializer.Get<ClientContext &>(), catalog, schema, table);
 	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
 		throw SerializationException("Cant find table for %s.%s", schema, table);
 	}
 	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
-	deserializer.ReadProperty("is_index_scan", result->is_index_scan);
-	deserializer.ReadProperty("is_create_index", result->is_create_index);
-	deserializer.ReadProperty("result_ids", result->result_ids);
-	deserializer.ReadProperty("result_ids", result->result_ids);
+	deserializer.ReadProperty(103, "is_index_scan", result->is_index_scan);
+	deserializer.ReadProperty(104, "is_create_index", result->is_create_index);
+	deserializer.ReadProperty(105, "result_ids", result->result_ids);
+	deserializer.ReadProperty(106, "result_ids", result->result_ids);
 	return std::move(result);
 }