duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -85,12 +85,14 @@ void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
 	}
 
 	// LHS child is a window
-	if (delim_join.children[0]->type != LogicalOperatorType::LOGICAL_WINDOW) {
+	idx_t delim_idx = delim_join.delim_flipped ? 1 : 0;
+	idx_t other_idx = 1 - delim_idx;
+	if (delim_join.children[delim_idx]->type != LogicalOperatorType::LOGICAL_WINDOW) {
 		return;
 	}
 
 	// RHS child must be projection(s) followed by an UNNEST
-	auto curr_op = &delim_join.children[1];
+	auto curr_op = &delim_join.children[other_idx];
 	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 		if (curr_op->get()->children.size() != 1) {
 			break;
@@ -116,20 +118,23 @@ bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
 
 	// get the LOGICAL_DELIM_JOIN, which is a child of the candidate
 	D_ASSERT(topmost_op.children.size() == 1);
-	auto &delim_join = *(topmost_op.children[0]);
+	auto &delim_join = topmost_op.children[0]->Cast<LogicalComparisonJoin>();
 	D_ASSERT(delim_join.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	GetDelimColumns(delim_join);
 
 	// LHS of the LOGICAL_DELIM_JOIN is a LOGICAL_WINDOW that contains a LOGICAL_PROJECTION
 	// this lhs_proj later becomes the child of the UNNEST
-	auto &window = *delim_join.children[0];
+
+	idx_t delim_idx = delim_join.delim_flipped ? 1 : 0;
+	idx_t other_idx = 1 - delim_idx;
+	auto &window = *delim_join.children[delim_idx];
 	auto &lhs_op = window.children[0];
 	GetLHSExpressions(*lhs_op);
 
 	// find the LOGICAL_UNNEST
 	// and get the path down to the LOGICAL_UNNEST
 	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
-	auto curr_op = &(delim_join.children[1]);
+	auto curr_op = &delim_join.children[other_idx];
 	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 		path_to_unnest.push_back(curr_op);
 		curr_op = &curr_op->get()->children[0];
@@ -160,7 +165,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 	idx_t shift = lhs_bindings.size();
 
 	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
-	auto curr_op = &(topmost_op.children[0]);
+	auto curr_op = &topmost_op.children[0];
 	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 
 		path_to_unnest.push_back(curr_op);
@@ -253,7 +258,7 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 	auto &topmost_op = (LogicalOperator &)**candidate;
 
 	// traverse LOGICAL_PROJECTION(s)
-	auto curr_op = &(topmost_op.children[0]);
+	auto curr_op = &topmost_op.children[0];
 	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 		curr_op = &curr_op->get()->children[0];
 	}

package/src/duckdb/src/parallel/event.cpp

@@ -44,11 +44,11 @@ void Event::AddDependency(Event &event) {
 	total_dependencies++;
 	event.parents.push_back(weak_ptr<Event>(shared_from_this()));
 #ifdef DEBUG
-	event.parents_raw.push_back(this);
+	event.parents_raw.push_back(*this);
 #endif
 }
 
-const vector<Event *> &Event::GetParentsVerification() const {
+const vector<reference<Event>> &Event::GetParentsVerification() const {
 	D_ASSERT(parents.size() == parents_raw.size());
 	return parents_raw;
 }

package/src/duckdb/src/parallel/executor.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
 #include "duckdb/execution/operator/set/physical_cte.hpp"
+#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
@@ -97,7 +97,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 		// create events/stack for this pipeline
 		auto pipeline_event = make_shared<PipelineEvent>(pipeline);
 
-		auto finish_group = meta_pipeline->GetFinishGroup(pipeline.get());
+		auto finish_group = meta_pipeline->GetFinishGroup(*pipeline);
 		if (finish_group) {
 			// this pipeline is part of a finish group
 			const auto group_entry = event_map.find(*finish_group.get());
@@ -112,7 +112,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 
 			// add pipeline stack to event map
 			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
-		} else if (meta_pipeline->HasFinishEvent(pipeline.get())) {
+		} else if (meta_pipeline->HasFinishEvent(*pipeline)) {
 			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
 			auto pipeline_finish_event = make_shared<PipelineFinishEvent>(pipeline);
 			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
@@ -126,7 +126,6 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 
 			// add pipeline stack to event map
 			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
-
 		} else {
 			// no additional finish event
 			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
@@ -154,7 +153,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			pipeline->ResetSource(true);
 		}
 
-		auto dependencies = meta_pipeline->GetDependencies(pipeline.get());
+		auto dependencies = meta_pipeline->GetDependencies(*pipeline);
 		if (!dependencies) {
 			continue;
 		}
@@ -162,7 +161,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 		D_ASSERT(root_entry != event_map.end());
 		auto &pipeline_stack = root_entry->second;
 		for (auto &dependency : *dependencies) {
-			auto event_entry = event_map.find(*dependency);
+			auto event_entry = event_map.find(dependency);
 			D_ASSERT(event_entry != event_map.end());
 			auto &dependency_stack = event_entry->second;
 			pipeline_stack.pipeline_event.AddDependency(dependency_stack.pipeline_event);
@@ -175,8 +174,8 @@ void Executor::ScheduleEventsInternal(ScheduleEventData &event_data) {
 	D_ASSERT(events.empty());
 
 	// create all the required pipeline events
-	for (auto &pipeline : event_data.meta_pipelines) {
-		SchedulePipeline(pipeline, event_data);
+	for (auto &meta_pipeline : event_data.meta_pipelines) {
+		SchedulePipeline(meta_pipeline, event_data);
 	}
 
 	// set up the dependencies across MetaPipelines
@@ -187,12 +186,36 @@ void Executor::ScheduleEventsInternal(ScheduleEventData &event_data) {
 			auto dep = dependency.lock();
 			D_ASSERT(dep);
 			auto event_map_entry = event_map.find(*dep);
+			if (event_map_entry == event_map.end()) {
+				continue;
+			}
 			D_ASSERT(event_map_entry != event_map.end());
 			auto &dep_entry = event_map_entry->second;
 			entry.second.pipeline_event.AddDependency(dep_entry.pipeline_complete_event);
 		}
 	}
 
+	// make pipeline_finish_event of each MetaPipeline depend on the pipeline_event of the base pipeline of its sublings
+	// this allows TemporaryMemoryManager to more fairly distribute memory
+	for (auto &meta_pipeline : event_data.meta_pipelines) {
+		vector<shared_ptr<MetaPipeline>> children;
+		meta_pipeline->GetMetaPipelines(children, false, true);
+		for (auto &child1 : children) {
+			auto &child1_base = *child1->GetBasePipeline();
+			auto child1_entry = event_map.find(child1_base);
+			D_ASSERT(child1_entry != event_map.end());
+			for (auto &child2 : children) {
+				if (RefersToSameObject(*child1, *child2)) {
+					continue;
+				}
+				auto &child2_base = *child2->GetBasePipeline();
+				auto child2_entry = event_map.find(child2_base);
+				D_ASSERT(child2_entry != event_map.end());
+				child1_entry->second.pipeline_finish_event.AddDependency(child2_entry->second.pipeline_event);
+			}
+		}
+	}
+
 	// verify that we have no cyclic dependencies
 	VerifyScheduledEvents(event_data);
 
@@ -212,10 +235,10 @@ void Executor::ScheduleEvents(const vector<shared_ptr<MetaPipeline>> &meta_pipel
 void Executor::VerifyScheduledEvents(const ScheduleEventData &event_data) {
 #ifdef DEBUG
 	const idx_t count = event_data.events.size();
-	vector<Event *> vertices;
+	vector<reference<Event>> vertices;
 	vertices.reserve(count);
 	for (const auto &event : event_data.events) {
-		vertices.push_back(event.get());
+		vertices.push_back(*event);
 	}
 	vector<bool> visited(count, false);
 	vector<bool> recursion_stack(count, false);
@@ -225,14 +248,14 @@ void Executor::VerifyScheduledEvents(const ScheduleEventData &event_data) {
 #endif
 }
 
-void Executor::VerifyScheduledEventsInternal(const idx_t vertex, const vector<Event *> &vertices, vector<bool> &visited,
-                                             vector<bool> &recursion_stack) {
+void Executor::VerifyScheduledEventsInternal(const idx_t vertex, const vector<reference<Event>> &vertices,
+                                             vector<bool> &visited, vector<bool> &recursion_stack) {
 	D_ASSERT(!recursion_stack[vertex]); // this vertex is in the recursion stack: circular dependency!
 	if (visited[vertex]) {
 		return; // early out: we already visited this vertex
 	}
 
-	auto &parents = vertices[vertex]->GetParentsVerification();
+	auto &parents = vertices[vertex].get().GetParentsVerification();
 	if (parents.empty()) {
 		return; // early out: outgoing edges
 	}
@@ -243,7 +266,7 @@ void Executor::VerifyScheduledEventsInternal(const idx_t vertex, const vector<Ev
 	for (auto parent : parents) {
 		idx_t i;
 		for (i = 0; i < count; i++) {
-			if (vertices[i] == parent) {
+			if (RefersToSameObject(vertices[i], parent)) {
 				adjacent.push_back(i);
 				break;
 			}
@@ -268,10 +291,6 @@ void Executor::AddRecursiveCTE(PhysicalOperator &rec_cte) {
 	recursive_ctes.push_back(rec_cte);
 }
 
-void Executor::AddMaterializedCTE(PhysicalOperator &mat_cte) {
-	materialized_ctes.push_back(mat_cte);
-}
-
 void Executor::ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines_p,
                                    vector<shared_ptr<Event>> &events_p) {
 	ScheduleEventData event_data(pipelines_p, events_p, false);
@@ -315,9 +334,9 @@ void Executor::VerifyPipelines() {
 #endif
 }
 
-void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan) {
+void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan_p) {
 	Reset();
-	owned_plan = std::move(physical_plan);
+	owned_plan = std::move(physical_plan_p);
 	InitializeInternal(*owned_plan);
 }
 
@@ -349,12 +368,6 @@ void Executor::InitializeInternal(PhysicalOperator &plan) {
 			rec_cte.recursive_meta_pipeline->Ready();
 		}
 
-		// ready materialized cte pipelines too
-		for (auto &mat_cte_ref : materialized_ctes) {
-			auto &mat_cte = mat_cte_ref.get().Cast<PhysicalCTE>();
-			mat_cte.recursive_meta_pipeline->Ready();
-		}
-
 		// set root pipelines, i.e., all pipelines that end in the final sink
 		root_pipeline->GetPipelines(root_pipelines, false);
 		root_pipeline_idx = 0;
@@ -392,16 +405,14 @@ void Executor::CancelTasks() {
 			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
 			rec_cte.recursive_meta_pipeline.reset();
 		}
-		for (auto &mat_cte_ref : materialized_ctes) {
-			auto &mat_cte = mat_cte_ref.get().Cast<PhysicalCTE>();
-			mat_cte.recursive_meta_pipeline.reset();
-		}
 		pipelines.clear();
 		root_pipelines.clear();
 		to_be_rescheduled_tasks.clear();
 		events.clear();
 	}
+	// Take all pending tasks and execute them until they cancel
 	WorkOnTasks();
+	// In case there are still tasks being worked, wait for those to properly finish as well
 	for (auto &weak_ref : weak_references) {
 		while (true) {
 			auto weak = weak_ref.lock();
@@ -415,49 +426,71 @@ void Executor::CancelTasks() {
 void Executor::WorkOnTasks() {
 	auto &scheduler = TaskScheduler::GetScheduler(context);
 
-	shared_ptr<Task> task;
-	while (scheduler.GetTaskFromProducer(*producer, task)) {
-		auto res = task->Execute(TaskExecutionMode::PROCESS_ALL);
+	shared_ptr<Task> task_from_producer;
+	while (scheduler.GetTaskFromProducer(*producer, task_from_producer)) {
+		auto res = task_from_producer->Execute(TaskExecutionMode::PROCESS_ALL);
 		if (res == TaskExecutionResult::TASK_BLOCKED) {
-			task->Deschedule();
+			task_from_producer->Deschedule();
 		}
-		task.reset();
+		task_from_producer.reset();
 	}
 }
 
-void Executor::RescheduleTask(shared_ptr<Task> &task) {
+void Executor::RescheduleTask(shared_ptr<Task> &task_p) {
 	// This function will spin lock until the task provided is added to the to_be_rescheduled_tasks
 	while (true) {
 		lock_guard<mutex> l(executor_lock);
 		if (cancelled) {
 			return;
 		}
-		auto entry = to_be_rescheduled_tasks.find(task.get());
+		auto entry = to_be_rescheduled_tasks.find(task_p.get());
 		if (entry != to_be_rescheduled_tasks.end()) {
 			auto &scheduler = TaskScheduler::GetScheduler(context);
-			to_be_rescheduled_tasks.erase(task.get());
-			scheduler.ScheduleTask(GetToken(), task);
+			to_be_rescheduled_tasks.erase(task_p.get());
+			scheduler.ScheduleTask(GetToken(), task_p);
 			break;
 		}
 	}
 }
 
-void Executor::AddToBeRescheduled(shared_ptr<Task> &task) {
+bool Executor::ResultCollectorIsBlocked() {
+	if (completed_pipelines + 1 != total_pipelines) {
+		// The result collector is always in the last pipeline
+		return false;
+	}
+	lock_guard<mutex> l(executor_lock);
+	if (to_be_rescheduled_tasks.empty()) {
+		return false;
+	}
+	for (auto &kv : to_be_rescheduled_tasks) {
+		auto &task = kv.second;
+		if (task->TaskBlockedOnResult()) {
+			// At least one of the blocked tasks is connected to a result collector
+			// This task could be the only task that could unblock the other non-result-collector tasks
+			// To prevent a scenario where we halt indefinitely, we return here so it can be unblocked by a call to
+			// Fetch
+			return true;
+		}
+	}
+	return false;
+}
+
+void Executor::AddToBeRescheduled(shared_ptr<Task> &task_p) {
 	lock_guard<mutex> l(executor_lock);
 	if (cancelled) {
 		return;
 	}
-	if (to_be_rescheduled_tasks.find(task.get()) != to_be_rescheduled_tasks.end()) {
+	if (to_be_rescheduled_tasks.find(task_p.get()) != to_be_rescheduled_tasks.end()) {
 		return;
 	}
-	to_be_rescheduled_tasks[task.get()] = std::move(task);
+	to_be_rescheduled_tasks[task_p.get()] = std::move(task_p);
 }
 
 bool Executor::ExecutionIsFinished() {
 	return completed_pipelines >= total_pipelines || HasError();
 }
 
-PendingExecutionResult Executor::ExecuteTask() {
+PendingExecutionResult Executor::ExecuteTask(bool dry_run) {
 	// Only executor should return NO_TASKS_AVAILABLE
 	D_ASSERT(execution_result != PendingExecutionResult::NO_TASKS_AVAILABLE);
 	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
@@ -467,14 +500,29 @@ PendingExecutionResult Executor::ExecuteTask() {
 	auto &scheduler = TaskScheduler::GetScheduler(context);
 	while (completed_pipelines < total_pipelines) {
 		// there are! if we don't already have a task, fetch one
-		if (!task) {
-			scheduler.GetTaskFromProducer(*producer, task);
+		auto current_task = task.get();
+		if (dry_run) {
+			// Pretend we have no task, we don't want to execute anything
+			current_task = nullptr;
+		} else {
+			if (!task) {
+				scheduler.GetTaskFromProducer(*producer, task);
+			}
+			current_task = task.get();
 		}
-		if (!task && !HasError()) {
+
+		if (!current_task && !HasError()) {
 			// there are no tasks to be scheduled and there are tasks blocked
+			if (ResultCollectorIsBlocked()) {
+				// The blocked tasks are processing the Sink of a BufferedResultCollector
+				// We return here so the query result can be made and fetched from
+				// which will in turn unblock the Sink tasks.
+				return PendingExecutionResult::BLOCKED;
+			}
 			return PendingExecutionResult::NO_TASKS_AVAILABLE;
 		}
-		if (task) {
+
+		if (current_task) {
 			// if we have a task, partially process it
 			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
 			if (result == TaskExecutionResult::TASK_BLOCKED) {
@@ -521,7 +569,7 @@ void Executor::Reset() {
 	root_pipeline_idx = 0;
 	completed_pipelines = 0;
 	total_pipelines = 0;
-	exceptions.clear();
+	error_manager.Reset();
 	pipelines.clear();
 	events.clear();
 	to_be_rescheduled_tasks.clear();
@@ -553,36 +601,37 @@ vector<LogicalType> Executor::GetTypes() {
 	return physical_plan->GetTypes();
 }
 
-void Executor::PushError(PreservedError exception) {
-	lock_guard<mutex> elock(error_lock);
+void Executor::PushError(ErrorData exception) {
+	// push the exception onto the stack
+	error_manager.PushError(std::move(exception));
 	// interrupt execution of any other pipelines that belong to this executor
 	context.interrupted = true;
-	// push the exception onto the stack
-	exceptions.push_back(std::move(exception));
 }
 
 bool Executor::HasError() {
-	lock_guard<mutex> elock(error_lock);
-	return !exceptions.empty();
+	return error_manager.HasError();
+}
+
+ErrorData Executor::GetError() {
+	return error_manager.GetError();
 }
 
 void Executor::ThrowException() {
-	lock_guard<mutex> elock(error_lock);
-	D_ASSERT(!exceptions.empty());
-	auto &entry = exceptions[0];
-	entry.Throw();
+	error_manager.ThrowException();
 }
 
 void Executor::Flush(ThreadContext &tcontext) {
 	profiler->Flush(tcontext.profiler);
 }
 
-bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_START
+bool Executor::GetPipelinesProgress(double &current_progress, uint64_t &current_cardinality,
+                                    uint64_t &total_cardinality) { // LCOV_EXCL_START
 	lock_guard<mutex> elock(executor_lock);
 
 	vector<double> progress;
 	vector<idx_t> cardinality;
-	idx_t total_cardinality = 0;
+	total_cardinality = 0;
+	current_cardinality = 0;
 	for (auto &pipeline : pipelines) {
 		double child_percentage;
 		idx_t child_cardinality;
@@ -594,12 +643,16 @@ bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_STA
 		cardinality.push_back(child_cardinality);
 		total_cardinality += child_cardinality;
 	}
-	current_progress = 0;
 	if (total_cardinality == 0) {
 		return true;
 	}
+	current_progress = 0;
+
 	for (size_t i = 0; i < progress.size(); i++) {
+		D_ASSERT(progress[i] <= 100);
+		current_cardinality += double(progress[i]) * double(cardinality[i]) / double(100);
 		current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality);
+		D_ASSERT(current_cardinality <= total_cardinality);
 	}
 	return true;
 } // LCOV_EXCL_STOP
@@ -615,24 +668,4 @@ unique_ptr<QueryResult> Executor::GetResult() {
 	return result_collector.GetResult(*result_collector.sink_state);
 }
 
-unique_ptr<DataChunk> Executor::FetchChunk() {
-	D_ASSERT(physical_plan);
-
-	auto chunk = make_uniq<DataChunk>();
-	root_executor->InitializeChunk(*chunk);
-	while (true) {
-		root_executor->ExecutePull(*chunk);
-		if (chunk->size() == 0) {
-			root_executor->PullFinalize();
-			if (NextExecutor()) {
-				continue;
-			}
-			break;
-		} else {
-			break;
-		}
-	}
-	return chunk;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parallel/executor_task.cpp

@@ -26,12 +26,10 @@ void ExecutorTask::Reschedule() {
 TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 	try {
 		return ExecuteTask(mode);
-	} catch (Exception &ex) {
-		executor.PushError(PreservedError(ex));
 	} catch (std::exception &ex) {
-		executor.PushError(PreservedError(ex));
+		executor.PushError(ErrorData(ex));
 	} catch (...) { // LCOV_EXCL_START
-		executor.PushError(PreservedError("Unknown exception in Finalize!"));
+		executor.PushError(ErrorData("Unknown exception in Finalize!"));
 	} // LCOV_EXCL_STOP
 	return TaskExecutionResult::TASK_ERROR;
 }

package/src/duckdb/src/parallel/meta_pipeline.cpp

@@ -1,11 +1,10 @@
 #include "duckdb/parallel/meta_pipeline.hpp"
 
 #include "duckdb/execution/executor.hpp"
-#include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
 
 namespace duckdb {
 
-MetaPipeline::MetaPipeline(Executor &executor_p, PipelineBuildState &state_p, PhysicalOperator *sink_p)
+MetaPipeline::MetaPipeline(Executor &executor_p, PipelineBuildState &state_p, optional_ptr<PhysicalOperator> sink_p)
     : executor(executor_p), state(state_p), sink(sink_p), recursive_cte(false), next_batch_index(0) {
 	CreatePipeline();
 }
@@ -46,7 +45,7 @@ void MetaPipeline::GetMetaPipelines(vector<shared_ptr<MetaPipeline>> &result, bo
 	}
 }
 
-const vector<Pipeline *> *MetaPipeline::GetDependencies(Pipeline *dependant) const {
+optional_ptr<const vector<reference<Pipeline>>> MetaPipeline::GetDependencies(Pipeline &dependant) const {
 	auto it = dependencies.find(dependant);
 	if (it == dependencies.end()) {
 		return nullptr;
@@ -63,8 +62,8 @@ void MetaPipeline::SetRecursiveCTE() {
 	recursive_cte = true;
 }
 
-void MetaPipeline::AssignNextBatchIndex(Pipeline *pipeline) {
-	pipeline->base_batch_index = next_batch_index++ * PipelineBuildState::BATCH_INCREMENT;
+void MetaPipeline::AssignNextBatchIndex(Pipeline &pipeline) {
+	pipeline.base_batch_index = next_batch_index++ * PipelineBuildState::BATCH_INCREMENT;
 }
 
 void MetaPipeline::Build(PhysicalOperator &op) {
@@ -92,16 +91,16 @@ MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalO
 	return *child_meta_pipeline;
 }
 
-Pipeline *MetaPipeline::CreatePipeline() {
+Pipeline &MetaPipeline::CreatePipeline() {
 	pipelines.emplace_back(make_shared<Pipeline>(executor));
 	state.SetPipelineSink(*pipelines.back(), sink, next_batch_index++);
-	return pipelines.back().get();
+	return *pipelines.back();
 }
 
-void MetaPipeline::AddDependenciesFrom(Pipeline *dependant, Pipeline *start, bool including) {
+void MetaPipeline::AddDependenciesFrom(Pipeline &dependant, Pipeline &start, bool including) {
 	// find 'start'
 	auto it = pipelines.begin();
-	for (; it->get() != start; it++) {
+	for (; !RefersToSameObject(**it, start); it++) {
 	}
 
 	if (!including) {
@@ -109,13 +108,13 @@ void MetaPipeline::AddDependenciesFrom(Pipeline *dependant, Pipeline *start, boo
 	}
 
 	// collect pipelines that were created from then
-	vector<Pipeline *> created_pipelines;
+	vector<reference<Pipeline>> created_pipelines;
 	for (; it != pipelines.end(); it++) {
-		if (it->get() == dependant) {
+		if (RefersToSameObject(**it, dependant)) {
 			// cannot depend on itself
 			continue;
 		}
-		created_pipelines.push_back(it->get());
+		created_pipelines.push_back(**it);
 	}
 
 	// add them to the dependencies
@@ -123,62 +122,62 @@ void MetaPipeline::AddDependenciesFrom(Pipeline *dependant, Pipeline *start, boo
 	deps.insert(deps.begin(), created_pipelines.begin(), created_pipelines.end());
 }
 
-void MetaPipeline::AddFinishEvent(Pipeline *pipeline) {
+void MetaPipeline::AddFinishEvent(Pipeline &pipeline) {
 	D_ASSERT(finish_pipelines.find(pipeline) == finish_pipelines.end());
 	finish_pipelines.insert(pipeline);
 
 	// add all pipelines that were added since 'pipeline' was added (including 'pipeline') to the finish group
 	auto it = pipelines.begin();
-	for (; it->get() != pipeline; it++) {
+	for (; !RefersToSameObject(**it, pipeline); it++) {
 	}
 	it++;
 	for (; it != pipelines.end(); it++) {
-		finish_map.emplace(it->get(), pipeline);
+		finish_map.emplace(**it, pipeline);
 	}
 }
 
-bool MetaPipeline::HasFinishEvent(Pipeline *pipeline) const {
+bool MetaPipeline::HasFinishEvent(Pipeline &pipeline) const {
 	return finish_pipelines.find(pipeline) != finish_pipelines.end();
 }
 
-optional_ptr<Pipeline> MetaPipeline::GetFinishGroup(Pipeline *pipeline) const {
+optional_ptr<Pipeline> MetaPipeline::GetFinishGroup(Pipeline &pipeline) const {
 	auto it = finish_map.find(pipeline);
-	return it == finish_map.end() ? nullptr : it->second;
+	return it == finish_map.end() ? nullptr : &it->second;
 }
 
-Pipeline *MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matters) {
+Pipeline &MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matters) {
 	// create the union pipeline (batch index 0, should be set correctly afterwards)
-	auto union_pipeline = CreatePipeline();
-	state.SetPipelineOperators(*union_pipeline, state.GetPipelineOperators(current));
-	state.SetPipelineSink(*union_pipeline, sink, 0);
+	auto &union_pipeline = CreatePipeline();
+	state.SetPipelineOperators(union_pipeline, state.GetPipelineOperators(current));
+	state.SetPipelineSink(union_pipeline, sink, 0);
 
 	// 'union_pipeline' inherits ALL dependencies of 'current' (within this MetaPipeline, and across MetaPipelines)
-	union_pipeline->dependencies = current.dependencies;
-	auto current_deps = GetDependencies(&current);
+	union_pipeline.dependencies = current.dependencies;
+	auto current_deps = GetDependencies(current);
 	if (current_deps) {
 		dependencies[union_pipeline] = *current_deps;
 	}
 
 	if (order_matters) {
 		// if we need to preserve order, or if the sink is not parallel, we set a dependency
-		dependencies[union_pipeline].push_back(&current);
+		dependencies[union_pipeline].push_back(current);
 	}
 
 	return union_pipeline;
 }
 
-void MetaPipeline::CreateChildPipeline(Pipeline &current, PhysicalOperator &op, Pipeline *last_pipeline) {
+void MetaPipeline::CreateChildPipeline(Pipeline &current, PhysicalOperator &op, Pipeline &last_pipeline) {
 	// rule 2: 'current' must be fully built (down to the source) before creating the child pipeline
 	D_ASSERT(current.source);
 
 	// create the child pipeline (same batch index)
 	pipelines.emplace_back(state.CreateChildPipeline(executor, current, op));
-	auto child_pipeline = pipelines.back().get();
-	child_pipeline->base_batch_index = current.base_batch_index;
+	auto &child_pipeline = *pipelines.back();
+	child_pipeline.base_batch_index = current.base_batch_index;
 
 	// child pipeline has a dependency (within this MetaPipeline on all pipelines that were scheduled
 	// between 'current' and now (including 'current') - set them up
-	dependencies[child_pipeline].push_back(&current);
+	dependencies[child_pipeline].push_back(current);
 	AddDependenciesFrom(child_pipeline, last_pipeline, false);
 	D_ASSERT(!GetDependencies(child_pipeline)->empty());
 }