duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -11,8 +11,8 @@
 #include "duckdb/parallel/meta_pipeline.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
-
-#include <thread>
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/thread.hpp"
 
 namespace duckdb {
 
@@ -87,17 +87,17 @@ public:
 		lhs_layout.Initialize(op.children[0]->types);
 		vector<BoundOrderByNode> lhs_order;
 		lhs_order.emplace_back(op.lhs_orders[0].Copy());
-		tables[0] = make_uniq<GlobalSortedTable>(context, lhs_order, lhs_layout);
+		tables[0] = make_uniq<GlobalSortedTable>(context, lhs_order, lhs_layout, op);
 
 		RowLayout rhs_layout;
 		rhs_layout.Initialize(op.children[1]->types);
 		vector<BoundOrderByNode> rhs_order;
 		rhs_order.emplace_back(op.rhs_orders[0].Copy());
-		tables[1] = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout);
+		tables[1] = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout, op);
 	}
 
-	IEJoinGlobalState(IEJoinGlobalState &prev)
-	    : GlobalSinkState(prev), tables(std::move(prev.tables)), child(prev.child + 1) {
+	IEJoinGlobalState(IEJoinGlobalState &prev) : tables(std::move(prev.tables)), child(prev.child + 1) {
+		state = prev.state;
 	}
 
 	void Sink(DataChunk &input, IEJoinLocalState &lstate) {
@@ -147,7 +147,7 @@ SinkCombineResultType PhysicalIEJoin::Combine(ExecutionContext &context, Operato
 	gstate.tables[gstate.child]->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
-	context.thread.profiler.Flush(*this, lstate.table.executor, gstate.child ? "rhs_executor" : "lhs_executor", 1);
+	context.thread.profiler.Flush(*this);
 	client_profiler.Flush(context.thread.profiler);
 
 	return SinkCombineResultType::FINISHED;
@@ -389,7 +389,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	vector<BoundOrderByNode> orders;
 	orders.emplace_back(order1.type, order1.null_order, std::move(ref));
 
-	l1 = make_uniq<SortedTable>(context, orders, payload_layout);
+	l1 = make_uniq<SortedTable>(context, orders, payload_layout, op);
 
 	// LHS has positive rids
 	ExpressionExecutor l_executor(context);
@@ -432,7 +432,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	ExpressionExecutor executor(context);
 	executor.AddExpression(*orders[0].expression);
 
-	l2 = make_uniq<SortedTable>(context, orders, payload_layout);
+	l2 = make_uniq<SortedTable>(context, orders, payload_layout, op);
 	for (idx_t base = 0, block_idx = 0; block_idx < l1->BlockCount(); ++block_idx) {
 		base += AppendKey(*l1, executor, *l2, 1, NumericCast<int64_t>(base), block_idx);
 	}
@@ -790,20 +790,20 @@ void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &re
 
 class IEJoinGlobalSourceState : public GlobalSourceState {
 public:
-	explicit IEJoinGlobalSourceState(const PhysicalIEJoin &op)
-	    : op(op), initialized(false), next_pair(0), completed(0), left_outers(0), next_left(0), right_outers(0),
-	      next_right(0) {
+	explicit IEJoinGlobalSourceState(const PhysicalIEJoin &op, IEJoinGlobalState &gsink)
+	    : op(op), gsink(gsink), initialized(false), next_pair(0), completed(0), left_outers(0), next_left(0),
+	      right_outers(0), next_right(0) {
 	}
 
-	void Initialize(IEJoinGlobalState &sink_state) {
-		lock_guard<mutex> initializing(lock);
+	void Initialize() {
+		auto guard = Lock();
 		if (initialized) {
 			return;
 		}
 
 		// Compute the starting row for reach block
 		// (In theory these are all the same size, but you never know...)
-		auto &left_table = *sink_state.tables[0];
+		auto &left_table = *gsink.tables[0];
 		const auto left_blocks = left_table.BlockCount();
 		idx_t left_base = 0;
 
@@ -812,7 +812,7 @@ public:
 			left_base += left_table.BlockSize(lhs);
 		}
 
-		auto &right_table = *sink_state.tables[1];
+		auto &right_table = *gsink.tables[1];
 		const auto right_blocks = right_table.BlockCount();
 		idx_t right_base = 0;
 		for (size_t rhs = 0; rhs < right_blocks; ++rhs) {
@@ -840,9 +840,9 @@ public:
 		return sink_state.tables[0]->BlockCount() * sink_state.tables[1]->BlockCount();
 	}
 
-	void GetNextPair(ClientContext &client, IEJoinGlobalState &gstate, IEJoinLocalSourceState &lstate) {
-		auto &left_table = *gstate.tables[0];
-		auto &right_table = *gstate.tables[1];
+	void GetNextPair(ClientContext &client, IEJoinLocalSourceState &lstate) {
+		auto &left_table = *gsink.tables[0];
+		auto &right_table = *gsink.tables[1];
 
 		const auto left_blocks = left_table.BlockCount();
 		const auto right_blocks = right_table.BlockCount();
@@ -905,35 +905,53 @@ public:
 		}
 	}
 
-	void PairCompleted(ClientContext &client, IEJoinGlobalState &gstate, IEJoinLocalSourceState &lstate) {
+	void PairCompleted(ClientContext &client, IEJoinLocalSourceState &lstate) {
 		lstate.joiner.reset();
 		++completed;
-		GetNextPair(client, gstate, lstate);
+		GetNextPair(client, lstate);
+	}
+
+	double GetProgress() const {
+		auto &left_table = *gsink.tables[0];
+		auto &right_table = *gsink.tables[1];
+
+		const auto left_blocks = left_table.BlockCount();
+		const auto right_blocks = right_table.BlockCount();
+		const auto pair_count = left_blocks * right_blocks;
+
+		const auto count = pair_count + left_outers + right_outers;
+
+		const auto l = MinValue(next_left.load(), left_outers.load());
+		const auto r = MinValue(next_right.load(), right_outers.load());
+		const auto returned = completed.load() + l + r;
+
+		return count ? (double(returned) / double(count)) : -1;
 	}
 
 	const PhysicalIEJoin &op;
+	IEJoinGlobalState &gsink;
 
-	mutex lock;
 	bool initialized;
 
 	// Join queue state
-	std::atomic<size_t> next_pair;
-	std::atomic<size_t> completed;
+	atomic<size_t> next_pair;
+	atomic<size_t> completed;
 
 	// Block base row number
 	vector<idx_t> left_bases;
 	vector<idx_t> right_bases;
 
 	// Outer joins
-	idx_t left_outers;
-	std::atomic<idx_t> next_left;
+	atomic<idx_t> left_outers;
+	atomic<idx_t> next_left;
 
-	idx_t right_outers;
-	std::atomic<idx_t> next_right;
+	atomic<idx_t> right_outers;
+	atomic<idx_t> next_right;
 };
 
 unique_ptr<GlobalSourceState> PhysicalIEJoin::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<IEJoinGlobalSourceState>(*this);
+	auto &gsink = sink_state->Cast<IEJoinGlobalState>();
+	return make_uniq<IEJoinGlobalSourceState>(*this, gsink);
 }
 
 unique_ptr<LocalSourceState> PhysicalIEJoin::GetLocalSourceState(ExecutionContext &context,
@@ -941,16 +959,21 @@ unique_ptr<LocalSourceState> PhysicalIEJoin::GetLocalSourceState(ExecutionContex
 	return make_uniq<IEJoinLocalSourceState>(context.client, *this);
 }
 
+double PhysicalIEJoin::GetProgress(ClientContext &context, GlobalSourceState &gsource_p) const {
+	auto &gsource = gsource_p.Cast<IEJoinGlobalSourceState>();
+	return gsource.GetProgress();
+}
+
 SourceResultType PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result,
                                          OperatorSourceInput &input) const {
 	auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
 	auto &ie_gstate = input.global_state.Cast<IEJoinGlobalSourceState>();
 	auto &ie_lstate = input.local_state.Cast<IEJoinLocalSourceState>();
 
-	ie_gstate.Initialize(ie_sink);
+	ie_gstate.Initialize();
 
 	if (!ie_lstate.joiner && !ie_lstate.left_matches && !ie_lstate.right_matches) {
-		ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
+		ie_gstate.GetNextPair(context.client, ie_lstate);
 	}
 
 	// Process INNER results
@@ -961,7 +984,7 @@ SourceResultType PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &r
 			return SourceResultType::HAVE_MORE_OUTPUT;
 		}
 
-		ie_gstate.PairCompleted(context.client, ie_sink, ie_lstate);
+		ie_gstate.PairCompleted(context.client, ie_lstate);
 	}
 
 	// Process LEFT OUTER results
@@ -969,7 +992,7 @@ SourceResultType PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &r
 	while (ie_lstate.left_matches) {
 		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.left_matches);
 		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
+			ie_gstate.GetNextPair(context.client, ie_lstate);
 			continue;
 		}
 		auto &chunk = ie_lstate.unprojected;
@@ -994,7 +1017,7 @@ SourceResultType PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &r
 	while (ie_lstate.right_matches) {
 		const idx_t count = ie_lstate.SelectOuterRows(ie_lstate.right_matches);
 		if (!count) {
-			ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
+			ie_gstate.GetNextPair(context.client, ie_lstate);
 			continue;
 		}
 

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

@@ -42,15 +42,29 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	meta_pipeline.GetPipelines(pipelines_so_far, false);
 	auto &last_pipeline = *pipelines_so_far.back();
 
+	vector<shared_ptr<Pipeline>> dependencies;
+	optional_ptr<MetaPipeline> last_child_ptr;
 	if (build_rhs) {
 		// on the RHS (build side), we construct a child MetaPipeline with this operator as its sink
-		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op);
+		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op, MetaPipelineType::JOIN_BUILD);
 		child_meta_pipeline.Build(*op.children[1]);
+		if (op.children[1]->CanSaturateThreads(current.GetClientContext())) {
+			// if the build side can saturate all available threads,
+			// we don't just make the LHS pipeline depend on the RHS, but recursively all LHS children too.
+			// this prevents breadth-first plan evaluation
+			child_meta_pipeline.GetPipelines(dependencies, false);
+			last_child_ptr = meta_pipeline.GetLastChild();
+		}
 	}
 
 	// continue building the current pipeline on the LHS (probe side)
 	op.children[0]->BuildPipelines(current, meta_pipeline);
 
+	if (last_child_ptr) {
+		// the pointer was set, set up the dependencies
+		meta_pipeline.AddRecursiveDependencies(dependencies, *last_child_ptr);
+	}
+
 	switch (op.type) {
 	case PhysicalOperatorType::POSITIONAL_JOIN:
 		// Positional joins are always outer
@@ -63,13 +77,7 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	}
 
 	// Join can become a source operator if it's RIGHT/OUTER, or if the hash join goes out-of-core
-	bool add_child_pipeline = false;
-	auto &join_op = op.Cast<PhysicalJoin>();
-	if (join_op.IsSource()) {
-		add_child_pipeline = true;
-	}
-
-	if (add_child_pipeline) {
+	if (op.Cast<PhysicalJoin>().IsSource()) {
 		meta_pipeline.CreateChildPipeline(current, op, last_pipeline);
 	}
 }

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

@@ -1,20 +1,19 @@
 #include "duckdb/execution/operator/join/physical_left_delim_join.hpp"
 
 #include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
+#include "duckdb/execution/operator/join/physical_join.hpp"
 #include "duckdb/execution/operator/scan/physical_column_data_scan.hpp"
 #include "duckdb/parallel/meta_pipeline.hpp"
 #include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/thread_context.hpp"
 
 namespace duckdb {
 
 PhysicalLeftDelimJoin::PhysicalLeftDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
                                              vector<const_reference<PhysicalOperator>> delim_scans,
-                                             idx_t estimated_cardinality)
+                                             idx_t estimated_cardinality, optional_idx delim_idx)
     : PhysicalDelimJoin(PhysicalOperatorType::LEFT_DELIM_JOIN, std::move(types), std::move(original_join),
-                        std::move(delim_scans), estimated_cardinality) {
+                        std::move(delim_scans), estimated_cardinality, delim_idx) {
 	D_ASSERT(join->children.size() == 2);
 	// now for the original join
 	// we take its left child, this is the side that we will duplicate eliminate
@@ -24,6 +23,9 @@ PhysicalLeftDelimJoin::PhysicalLeftDelimJoin(vector<LogicalType> types, unique_p
 	// the actual chunk collection to scan will be created in the LeftDelimJoinGlobalState
 	auto cached_chunk_scan = make_uniq<PhysicalColumnDataScan>(
 	    children[0]->GetTypes(), PhysicalOperatorType::COLUMN_DATA_SCAN, estimated_cardinality, nullptr);
+	if (delim_idx.IsValid()) {
+		cached_chunk_scan->cte_index = delim_idx.GetIndex();
+	}
 	join->children[0] = std::move(cached_chunk_scan);
 }
 
@@ -101,6 +103,10 @@ SinkCombineResultType PhysicalLeftDelimJoin::Combine(ExecutionContext &context,
 	return SinkCombineResultType::FINISHED;
 }
 
+void PhysicalLeftDelimJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const {
+	distinct->PrepareFinalize(context, *distinct->sink_state);
+}
+
 SinkFinalizeType PhysicalLeftDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
                                                  OperatorSinkFinalizeInput &input) const {
 	// finalize the distinct HT

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

@@ -200,12 +200,9 @@ SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, DataChunk
 
 SinkCombineResultType PhysicalNestedLoopJoin::Combine(ExecutionContext &context,
                                                       OperatorSinkCombineInput &input) const {
-	auto &state = input.local_state.Cast<NestedLoopJoinLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
-
-	context.thread.profiler.Flush(*this, state.rhs_executor, "rhs_executor", 1);
+	context.thread.profiler.Flush(*this);
 	client_profiler.Flush(context.thread.profiler);
-
 	return SinkCombineResultType::FINISHED;
 }
 
@@ -266,7 +263,7 @@ public:
 
 public:
 	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, lhs_executor, "lhs_executor", 0);
+		context.thread.profiler.Flush(op);
 	}
 };
 

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

@@ -76,7 +76,7 @@ public:
 		rhs_layout.Initialize(op.children[1]->types);
 		vector<BoundOrderByNode> rhs_order;
 		rhs_order.emplace_back(op.rhs_orders[0].Copy());
-		table = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout);
+		table = make_uniq<GlobalSortedTable>(context, rhs_order, rhs_layout, op);
 	}
 
 	inline idx_t Count() const {
@@ -125,7 +125,7 @@ SinkCombineResultType PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &cont
 	gstate.table->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
-	context.thread.profiler.Flush(*this, lstate.table.executor, "rhs_executor", 1);
+	context.thread.profiler.Flush(*this);
 	client_profiler.Flush(context.thread.profiler);
 
 	return SinkCombineResultType::FINISHED;
@@ -250,7 +250,7 @@ public:
 
 	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
 		if (lhs_local_table) {
-			context.thread.profiler.Flush(op, lhs_local_table->executor, "lhs_executor", 0);
+			context.thread.profiler.Flush(op);
 		}
 	}
 };

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

@@ -59,9 +59,9 @@ void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState
 }
 
 PhysicalRangeJoin::GlobalSortedTable::GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders,
-                                                        RowLayout &payload_layout)
-    : global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0), count(0),
-      memory_per_thread(0) {
+                                                        RowLayout &payload_layout, const PhysicalOperator &op_p)
+    : op(op_p), global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0),
+      count(0), memory_per_thread(0) {
 	D_ASSERT(orders.size() == 1);
 
 	// Set external (can be forced with the PRAGMA)
@@ -77,7 +77,7 @@ void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
 }
 
 void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
-	found_match = make_unsafe_uniq_array<bool>(Count());
+	found_match = make_unsafe_uniq_array_uninitialized<bool>(Count());
 	memset(found_match.get(), 0, sizeof(bool) * Count());
 }
 
@@ -91,7 +91,7 @@ public:
 
 public:
 	RangeJoinMergeTask(shared_ptr<Event> event_p, ClientContext &context, GlobalSortedTable &table)
-	    : ExecutorTask(context, std::move(event_p)), context(context), table(table) {
+	    : ExecutorTask(context, std::move(event_p), table.op), context(context), table(table) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {

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

@@ -12,9 +12,9 @@ namespace duckdb {
 
 PhysicalRightDelimJoin::PhysicalRightDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
                                                vector<const_reference<PhysicalOperator>> delim_scans,
-                                               idx_t estimated_cardinality)
+                                               idx_t estimated_cardinality, optional_idx delim_idx)
     : PhysicalDelimJoin(PhysicalOperatorType::RIGHT_DELIM_JOIN, std::move(types), std::move(original_join),
-                        std::move(delim_scans), estimated_cardinality) {
+                        std::move(delim_scans), estimated_cardinality, delim_idx) {
 	D_ASSERT(join->children.size() == 2);
 	// now for the original join
 	// we take its right child, this is the side that we will duplicate eliminate
@@ -79,6 +79,11 @@ SinkCombineResultType PhysicalRightDelimJoin::Combine(ExecutionContext &context,
 	return SinkCombineResultType::FINISHED;
 }
 
+void PhysicalRightDelimJoin::PrepareFinalize(ClientContext &context, GlobalSinkState &sink_state) const {
+	join->PrepareFinalize(context, *join->sink_state);
+	distinct->PrepareFinalize(context, *distinct->sink_state);
+}
+
 SinkFinalizeType PhysicalRightDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
                                                   OperatorSinkFinalizeInput &input) const {
 	D_ASSERT(join);

package/src/duckdb/src/execution/operator/order/physical_order.cpp

@@ -22,9 +22,10 @@ PhysicalOrder::PhysicalOrder(vector<LogicalType> types, vector<BoundOrderByNode>
 class OrderGlobalSinkState : public GlobalSinkState {
 public:
 	OrderGlobalSinkState(BufferManager &buffer_manager, const PhysicalOrder &order, RowLayout &payload_layout)
-	    : global_sort_state(buffer_manager, order.orders, payload_layout) {
+	    : order(order), global_sort_state(buffer_manager, order.orders, payload_layout) {
 	}
 
+	const PhysicalOrder &order;
 	//! Global sort state
 	GlobalSortState global_sort_state;
 	//! Memory usage per thread
@@ -112,8 +113,9 @@ SinkCombineResultType PhysicalOrder::Combine(ExecutionContext &context, Operator
 
 class PhysicalOrderMergeTask : public ExecutorTask {
 public:
-	PhysicalOrderMergeTask(shared_ptr<Event> event_p, ClientContext &context, OrderGlobalSinkState &state)
-	    : ExecutorTask(context, std::move(event_p)), context(context), state(state) {
+	PhysicalOrderMergeTask(shared_ptr<Event> event_p, ClientContext &context, OrderGlobalSinkState &state,
+	                       const PhysicalOperator &op_p)
+	    : ExecutorTask(context, std::move(event_p), op_p), context(context), state(state) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
@@ -132,11 +134,12 @@ private:
 
 class OrderMergeEvent : public BasePipelineEvent {
 public:
-	OrderMergeEvent(OrderGlobalSinkState &gstate_p, Pipeline &pipeline_p)
-	    : BasePipelineEvent(pipeline_p), gstate(gstate_p) {
+	OrderMergeEvent(OrderGlobalSinkState &gstate_p, Pipeline &pipeline_p, const PhysicalOperator &op_p)
+	    : BasePipelineEvent(pipeline_p), gstate(gstate_p), op(op_p) {
 	}
 
 	OrderGlobalSinkState &gstate;
+	const PhysicalOperator &op;
 
 public:
 	void Schedule() override {
@@ -148,7 +151,7 @@ public:
 
 		vector<shared_ptr<Task>> merge_tasks;
 		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			merge_tasks.push_back(make_uniq<PhysicalOrderMergeTask>(shared_from_this(), context, gstate));
+			merge_tasks.push_back(make_uniq<PhysicalOrderMergeTask>(shared_from_this(), context, gstate, op));
 		}
 		SetTasks(std::move(merge_tasks));
 	}
@@ -187,7 +190,7 @@ SinkFinalizeType PhysicalOrder::Finalize(Pipeline &pipeline, Event &event, Clien
 void PhysicalOrder::ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGlobalSinkState &state) {
 	// Initialize global sort state for a round of merging
 	state.global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared_ptr<OrderMergeEvent>(state, pipeline);
+	auto new_event = make_shared_ptr<OrderMergeEvent>(state, pipeline, state.order);
 	event.InsertEvent(std::move(new_event));
 }
 
@@ -267,15 +270,17 @@ idx_t PhysicalOrder::GetBatchIndex(ExecutionContext &context, DataChunk &chunk,
 	return lstate.batch_index;
 }
 
-string PhysicalOrder::ParamsToString() const {
-	string result = "ORDERS:\n";
+InsertionOrderPreservingMap<string> PhysicalOrder::ParamsToString() const {
+	InsertionOrderPreservingMap<string> result;
+	string orders_info;
 	for (idx_t i = 0; i < orders.size(); i++) {
 		if (i > 0) {
-			result += "\n";
+			orders_info += "\n";
 		}
-		result += orders[i].expression->ToString() + " ";
-		result += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
+		orders_info += orders[i].expression->ToString() + " ";
+		orders_info += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
 	}
+	result["__order_by__"] = orders_info;
 	return result;
 }
 

package/src/duckdb/src/execution/operator/order/physical_top_n.cpp

@@ -492,19 +492,22 @@ SourceResultType PhysicalTopN::GetData(ExecutionContext &context, DataChunk &chu
 	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
-string PhysicalTopN::ParamsToString() const {
-	string result;
-	result += "Top " + to_string(limit);
+InsertionOrderPreservingMap<string> PhysicalTopN::ParamsToString() const {
+	InsertionOrderPreservingMap<string> result;
+	result["Top"] = to_string(limit);
 	if (offset > 0) {
-		result += "\n";
-		result += "Offset " + to_string(offset);
+		result["Offset"] = to_string(offset);
 	}
-	result += "\n[INFOSEPARATOR]";
+
+	string orders_info;
 	for (idx_t i = 0; i < orders.size(); i++) {
-		result += "\n";
-		result += orders[i].expression->ToString() + " ";
-		result += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
+		if (i > 0) {
+			orders_info += "\n";
+		}
+		orders_info += orders[i].expression->ToString() + " ";
+		orders_info += orders[i].type == OrderType::DESCENDING ? "DESC" : "ASC";
 	}
+	result["Order By"] = orders_info;
 	return result;
 }
 

package/src/duckdb/src/execution/operator/persistent/physical_batch_copy_to_file.cpp

@@ -1,14 +1,16 @@
 #include "duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp"
-#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp"
-#include "duckdb/parallel/base_pipeline_event.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/types/batched_data_collection.hpp"
+
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/queue.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/types/batched_data_collection.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/operator/persistent/batch_memory_manager.hpp"
 #include "duckdb/execution/operator/persistent/batch_task_manager.hpp"
+#include "duckdb/execution/operator/persistent/physical_copy_to_file.hpp"
+#include "duckdb/parallel/base_pipeline_event.hpp"
 #include "duckdb/parallel/executor_task.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
 #include <algorithm>
 
 namespace duckdb {
@@ -158,15 +160,14 @@ SinkResultType PhysicalBatchCopyToFile::Sink(ExecutionContext &context, DataChun
 	auto batch_index = state.partition_info.batch_index.GetIndex();
 	if (state.current_task == FixedBatchCopyState::PROCESSING_TASKS) {
 		ExecuteTasks(context.client, gstate);
-		FlushBatchData(context.client, gstate, memory_manager.GetMinimumBatchIndex());
+		FlushBatchData(context.client, gstate);
 
 		if (!memory_manager.IsMinimumBatchIndex(batch_index) && memory_manager.OutOfMemory(batch_index)) {
-			lock_guard<mutex> l(memory_manager.GetBlockedTaskLock());
+			auto guard = memory_manager.Lock();
 			if (!memory_manager.IsMinimumBatchIndex(batch_index)) {
 				// no tasks to process, we are not the minimum batch index and we have no memory available to buffer
 				// block the task for now
-				memory_manager.BlockTask(input.interrupt_state);
-				return SinkResultType::BLOCKED;
+				return memory_manager.BlockSink(guard, input.interrupt_state);
 			}
 		}
 		state.current_task = FixedBatchCopyState::SINKING_DATA;
@@ -232,7 +233,7 @@ public:
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
 		while (op.ExecuteTask(context, gstate)) {
-			op.FlushBatchData(context, gstate, 0);
+			op.FlushBatchData(context, gstate);
 		}
 		event->FinishTask();
 		return TaskExecutionResult::TASK_FINISHED;
@@ -279,8 +280,8 @@ SinkFinalizeType PhysicalBatchCopyToFile::FinalFlush(ClientContext &context, Glo
 	if (gstate.task_manager.TaskCount() != 0) {
 		throw InternalException("Unexecuted tasks are remaining in PhysicalFixedBatchCopy::FinalFlush!?");
 	}
-	auto min_batch_index = idx_t(NumericLimits<int64_t>::Maximum());
-	FlushBatchData(context, gstate_p, min_batch_index);
+
+	FlushBatchData(context, gstate_p);
 	if (gstate.scheduled_batch_index != gstate.flushed_batch_index) {
 		throw InternalException("Not all batches were flushed to disk - incomplete file?");
 	}
@@ -323,7 +324,7 @@ public:
 	}
 
 	void Execute(const PhysicalBatchCopyToFile &op, ClientContext &context, GlobalSinkState &gstate_p) override {
-		op.FlushBatchData(context, gstate_p, 0);
+		op.FlushBatchData(context, gstate_p);
 	}
 };
 
@@ -475,7 +476,7 @@ void PhysicalBatchCopyToFile::RepartitionBatches(ClientContext &context, GlobalS
 	}
 }
 
-void PhysicalBatchCopyToFile::FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const {
+void PhysicalBatchCopyToFile::FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p) const {
 	auto &gstate = gstate_p.Cast<FixedBatchCopyGlobalState>();
 	auto &memory_manager = gstate.memory_manager;
 
@@ -554,14 +555,18 @@ void PhysicalBatchCopyToFile::AddLocalBatch(ClientContext &context, GlobalSinkSt
 	// attempt to repartition to our desired batch size
 	RepartitionBatches(context, gstate, min_batch_index);
 	// unblock tasks so they can help process batches (if any are blocked)
-	auto any_unblocked = memory_manager.UnblockTasks();
+	bool any_unblocked;
+	{
+		auto guard = memory_manager.Lock();
+		any_unblocked = memory_manager.UnblockTasks(guard);
+	}
 	// if any threads were unblocked they can pick up execution of the tasks
 	// otherwise we will execute a task and flush here
 	if (!any_unblocked) {
 		//! Execute a single repartition task
 		ExecuteTask(context, gstate);
 		//! Flush batch data to disk (if any is ready)
-		FlushBatchData(context, gstate, memory_manager.GetMinimumBatchIndex());
+		FlushBatchData(context, gstate);
 	}
 }
 
@@ -605,7 +610,20 @@ SourceResultType PhysicalBatchCopyToFile::GetData(ExecutionContext &context, Dat
 	auto &g = sink_state->Cast<FixedBatchCopyGlobalState>();
 
 	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
+	switch (return_type) {
+	case CopyFunctionReturnType::CHANGED_ROWS:
+		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
+		break;
+	case CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST: {
+		chunk.SetValue(0, 0, Value::BIGINT(NumericCast<int64_t>(g.rows_copied.load())));
+		auto fp = use_tmp_file ? PhysicalCopyToFile::GetNonTmpFile(context.client, file_path) : file_path;
+		chunk.SetValue(1, 0, Value::LIST(LogicalType::VARCHAR, {fp}));
+		break;
+	}
+	default:
+		throw NotImplementedException("Unknown CopyFunctionReturnType");
+	}
+
 	return SourceResultType::FINISHED;
 }