duckdb 0.7.2-dev2233.0 → 0.7.2-dev2320.0

package/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp

@@ -34,7 +34,7 @@ public:
 	static DuckTransaction &Get(ClientContext &context, Catalog &catalog);
 	LocalStorage &GetLocalStorage();
 
-	void PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data = nullptr, idx_t extra_data_size = 0);
+	void PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data = nullptr, idx_t extra_data_size = 0);
 
 	//! Commit the current transaction with the given commit identifier. Returns an error message if the transaction
 	//! commit failed, or an empty string if the commit was sucessful
@@ -49,8 +49,8 @@ public:
 
 	bool ChangesMade();
 
-	void PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row);
-	void PushAppend(DataTable *table, idx_t row_start, idx_t row_count);
+	void PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row);
+	void PushAppend(DataTable &table, idx_t row_start, idx_t row_count);
 	UpdateInfo *CreateUpdateInfo(idx_t type_size, idx_t entries);
 
 	bool IsDuckTransaction() const override {

package/src/duckdb/src/include/duckdb/transaction/local_storage.hpp

@@ -22,8 +22,8 @@ struct TableAppendState;
 
 class OptimisticDataWriter {
 public:
-	OptimisticDataWriter(DataTable *table);
-	OptimisticDataWriter(DataTable *table, OptimisticDataWriter &parent);
+	OptimisticDataWriter(DataTable &table);
+	OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent);
 	~OptimisticDataWriter();
 
 	void CheckFlushToDisk(RowGroupCollection &row_groups);
@@ -42,7 +42,7 @@ private:
 
 private:
 	//! The table
-	DataTable *table;
+	DataTable &table;
 	//! The partial block manager (if we created one yet)
 	unique_ptr<PartialBlockManager> partial_manager;
 	//! The set of blocks that have been pre-emptively written to disk
@@ -60,10 +60,10 @@ public:
 	LocalTableStorage(DataTable &table, LocalTableStorage &parent, idx_t drop_idx);
 	// Create a LocalTableStorage from an ADD COLUMN
 	LocalTableStorage(ClientContext &context, DataTable &table, LocalTableStorage &parent, ColumnDefinition &new_column,
-	                  Expression *default_value);
+	                  optional_ptr<Expression> default_value);
 	~LocalTableStorage();
 
-	DataTable *table;
+	reference<DataTable> table_ref;
 
 	Allocator &allocator;
 	//! The main chunk collection holding the data
@@ -78,7 +78,7 @@ public:
 	vector<unique_ptr<OptimisticDataWriter>> optimistic_writers;
 
 public:
-	void InitializeScan(CollectionScanState &state, TableFilterSet *table_filters = nullptr);
+	void InitializeScan(CollectionScanState &state, optional_ptr<TableFilterSet> table_filters = nullptr);
 	//! Check if we should flush the previously written row-group to disk
 	void CheckFlushToDisk();
 	//! Flushes the final row group to disk (if any)
@@ -92,22 +92,22 @@ public:
 	                               const vector<LogicalType> &table_types, row_t &start_row);
 
 	//! Creates an optimistic writer for this table
-	OptimisticDataWriter *CreateOptimisticWriter();
+	OptimisticDataWriter &CreateOptimisticWriter();
 };
 
 class LocalTableManager {
 public:
-	shared_ptr<LocalTableStorage> MoveEntry(DataTable *table);
-	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> MoveEntries();
-	LocalTableStorage *GetStorage(DataTable *table);
-	LocalTableStorage *GetOrCreateStorage(DataTable *table);
+	shared_ptr<LocalTableStorage> MoveEntry(DataTable &table);
+	reference_map_t<DataTable, shared_ptr<LocalTableStorage>> MoveEntries();
+	optional_ptr<LocalTableStorage> GetStorage(DataTable &table);
+	LocalTableStorage &GetOrCreateStorage(DataTable &table);
 	idx_t EstimatedSize();
 	bool IsEmpty();
-	void InsertEntry(DataTable *table, shared_ptr<LocalTableStorage> entry);
+	void InsertEntry(DataTable &table, shared_ptr<LocalTableStorage> entry);
 
 private:
 	mutex table_storage_lock;
-	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> table_storage;
+	reference_map_t<DataTable, shared_ptr<LocalTableStorage>> table_storage;
 };
 
 //! The LocalStorage class holds appends that have not been committed yet
@@ -121,7 +121,7 @@ public:
 		CommitState();
 		~CommitState();
 
-		unordered_map<DataTable *, unique_ptr<TableAppendState>> append_states;
+		reference_map_t<DataTable, unique_ptr<TableAppendState>> append_states;
 	};
 
 public:
@@ -132,29 +132,29 @@ public:
 	static LocalStorage &Get(ClientContext &context, Catalog &catalog);
 
 	//! Initialize a scan of the local storage
-	void InitializeScan(DataTable *table, CollectionScanState &state, TableFilterSet *table_filters);
+	void InitializeScan(DataTable &table, CollectionScanState &state, optional_ptr<TableFilterSet> table_filters);
 	//! Scan
 	void Scan(CollectionScanState &state, const vector<column_t> &column_ids, DataChunk &result);
 
-	void InitializeParallelScan(DataTable *table, ParallelCollectionScanState &state);
-	bool NextParallelScan(ClientContext &context, DataTable *table, ParallelCollectionScanState &state,
+	void InitializeParallelScan(DataTable &table, ParallelCollectionScanState &state);
+	bool NextParallelScan(ClientContext &context, DataTable &table, ParallelCollectionScanState &state,
 	                      CollectionScanState &scan_state);
 
 	//! Begin appending to the local storage
-	void InitializeAppend(LocalAppendState &state, DataTable *table);
+	void InitializeAppend(LocalAppendState &state, DataTable &table);
 	//! Append a chunk to the local storage
 	static void Append(LocalAppendState &state, DataChunk &chunk);
 	//! Finish appending to the local storage
 	static void FinalizeAppend(LocalAppendState &state);
 	//! Merge a row group collection into the transaction-local storage
-	void LocalMerge(DataTable *table, RowGroupCollection &collection);
+	void LocalMerge(DataTable &table, RowGroupCollection &collection);
 	//! Create an optimistic writer for the specified table
-	OptimisticDataWriter *CreateOptimisticWriter(DataTable *table);
+	OptimisticDataWriter &CreateOptimisticWriter(DataTable &table);
 
 	//! Delete a set of rows from the local storage
-	idx_t Delete(DataTable *table, Vector &row_ids, idx_t count);
+	idx_t Delete(DataTable &table, Vector &row_ids, idx_t count);
 	//! Update a set of rows in the local storage
-	void Update(DataTable *table, Vector &row_ids, const vector<PhysicalIndex> &column_ids, DataChunk &data);
+	void Update(DataTable &table, Vector &row_ids, const vector<PhysicalIndex> &column_ids, DataChunk &data);
 
 	//! Commits the local storage, writing it to the WAL and completing the commit
 	void Commit(LocalStorage::CommitState &commit_state, DuckTransaction &transaction);
@@ -164,19 +164,20 @@ public:
 	bool ChangesMade() noexcept;
 	idx_t EstimatedSize();
 
-	bool Find(DataTable *table);
+	bool Find(DataTable &table);
 
-	idx_t AddedRows(DataTable *table);
+	idx_t AddedRows(DataTable &table);
 
-	void AddColumn(DataTable *old_dt, DataTable *new_dt, ColumnDefinition &new_column, Expression *default_value);
-	void DropColumn(DataTable *old_dt, DataTable *new_dt, idx_t removed_column);
-	void ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t changed_idx, const LogicalType &target_type,
+	void AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
+	               optional_ptr<Expression> default_value);
+	void DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t removed_column);
+	void ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t changed_idx, const LogicalType &target_type,
 	                const vector<column_t> &bound_columns, Expression &cast_expr);
 
-	void MoveStorage(DataTable *old_dt, DataTable *new_dt);
-	void FetchChunk(DataTable *table, Vector &row_ids, idx_t count, const vector<column_t> &col_ids, DataChunk &chunk,
+	void MoveStorage(DataTable &old_dt, DataTable &new_dt);
+	void FetchChunk(DataTable &table, Vector &row_ids, idx_t count, const vector<column_t> &col_ids, DataChunk &chunk,
 	                ColumnFetchState &fetch_state);
-	TableIndexList &GetIndexes(DataTable *table);
+	TableIndexList &GetIndexes(DataTable &table);
 
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 

package/src/duckdb/src/include/duckdb/transaction/transaction_data.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class DuckTransaction;
@@ -18,7 +19,7 @@ struct TransactionData {
 	TransactionData(DuckTransaction &transaction_p);
 	TransactionData(transaction_t transaction_id_p, transaction_t start_time_p);
 
-	DuckTransaction *transaction;
+	optional_ptr<DuckTransaction> transaction;
 	transaction_t transaction_id;
 	transaction_t start_time;
 };

package/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp

@@ -40,7 +40,7 @@ public:
 	//! Cleanup the undo buffer
 	void Cleanup();
 	//! Commit the changes made in the UndoBuffer: should be called on commit
-	void Commit(UndoBuffer::IteratorState &iterator_state, WriteAheadLog *log, transaction_t commit_id);
+	void Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<WriteAheadLog> log, transaction_t commit_id);
 	//! Revert committed changes made in the UndoBuffer up until the currently committed state
 	void RevertCommit(UndoBuffer::IteratorState &iterator_state, transaction_t transaction_id);
 	//! Rollback the changes made in this UndoBuffer: should be called on

package/src/duckdb/src/main/client_context.cpp

@@ -419,7 +419,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 		D_ASSERT(collector->type == PhysicalOperatorType::RESULT_COLLECTOR);
 		executor.Initialize(std::move(collector));
 	} else {
-		executor.Initialize(statement.plan.get());
+		executor.Initialize(*statement.plan);
 	}
 	auto types = executor.GetTypes();
 	D_ASSERT(types == statement.types);

package/src/duckdb/src/main/query_profiler.cpp

@@ -208,7 +208,7 @@ void QueryProfiler::EndPhase() {
 	}
 }
 
-void QueryProfiler::Initialize(PhysicalOperator *root_op) {
+void QueryProfiler::Initialize(const PhysicalOperator &root_op) {
 	if (!IsEnabled() || !running) {
 		return;
 	}
@@ -227,7 +227,7 @@ void QueryProfiler::Initialize(PhysicalOperator *root_op) {
 OperatorProfiler::OperatorProfiler(bool enabled_p) : enabled(enabled_p), active_operator(nullptr) {
 }
 
-void OperatorProfiler::StartOperator(const PhysicalOperator *phys_op) {
+void OperatorProfiler::StartOperator(optional_ptr<const PhysicalOperator> phys_op) {
 	if (!enabled) {
 		return;
 	}
@@ -242,7 +242,7 @@ void OperatorProfiler::StartOperator(const PhysicalOperator *phys_op) {
 	op.Start();
 }
 
-void OperatorProfiler::EndOperator(DataChunk *chunk) {
+void OperatorProfiler::EndOperator(optional_ptr<DataChunk> chunk) {
 	if (!enabled) {
 		return;
 	}
@@ -254,11 +254,11 @@ void OperatorProfiler::EndOperator(DataChunk *chunk) {
 	// finish timing for the current element
 	op.End();
 
-	AddTiming(active_operator, op.Elapsed(), chunk ? chunk->size() : 0);
+	AddTiming(*active_operator, op.Elapsed(), chunk ? chunk->size() : 0);
 	active_operator = nullptr;
 }
 
-void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t elements) {
+void OperatorProfiler::AddTiming(const PhysicalOperator &op, double time, idx_t elements) {
 	if (!enabled) {
 		return;
 	}
@@ -275,7 +275,7 @@ void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t
 		entry->second.elements += elements;
 	}
 }
-void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor *expression_executor,
+void OperatorProfiler::Flush(const PhysicalOperator &phys_op, ExpressionExecutor &expression_executor,
                              const string &name, int id) {
 	auto entry = timings.find(phys_op);
 	if (entry == timings.end()) {
@@ -285,8 +285,8 @@ void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor
 	if (int(operator_timing.executors_info.size()) <= id) {
 		operator_timing.executors_info.resize(id + 1);
 	}
-	operator_timing.executors_info[id] = make_uniq<ExpressionExecutorInfo>(*expression_executor, name, id);
-	operator_timing.name = phys_op->GetName();
+	operator_timing.executors_info[id] = make_uniq<ExpressionExecutorInfo>(expression_executor, name, id);
+	operator_timing.name = phys_op.GetName();
 }
 
 void QueryProfiler::Flush(OperatorProfiler &profiler) {
@@ -295,11 +295,13 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 		return;
 	}
 	for (auto &node : profiler.timings) {
-		auto entry = tree_map.find(node.first);
+		auto &op = node.first.get();
+		auto entry = tree_map.find(op);
 		D_ASSERT(entry != tree_map.end());
+		auto &tree_node = entry->second.get();
 
-		entry->second->info.time += node.second.time;
-		entry->second->info.elements += node.second.elements;
+		tree_node.info.time += node.second.time;
+		tree_node.info.elements += node.second.elements;
 		if (!IsDetailedEnabled()) {
 			continue;
 		}
@@ -308,10 +310,10 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 				continue;
 			}
 			auto info_id = info->id;
-			if (int(entry->second->info.executors_info.size()) <= info_id) {
-				entry->second->info.executors_info.resize(info_id + 1);
+			if (int32_t(tree_node.info.executors_info.size()) <= info_id) {
+				tree_node.info.executors_info.resize(info_id + 1);
 			}
-			entry->second->info.executors_info[info_id] = std::move(info);
+			tree_node.info.executors_info[info_id] = std::move(info);
 		}
 	}
 	profiler.timings.clear();
@@ -610,19 +612,19 @@ void QueryProfiler::WriteToFile(const char *path, string &info) const {
 	}
 }
 
-unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(PhysicalOperator *root, idx_t depth) {
-	if (OperatorRequiresProfiling(root->type)) {
+unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(const PhysicalOperator &root, idx_t depth) {
+	if (OperatorRequiresProfiling(root.type)) {
 		this->query_requires_profiling = true;
 	}
 	auto node = make_uniq<QueryProfiler::TreeNode>();
-	node->type = root->type;
-	node->name = root->GetName();
-	node->extra_info = root->ParamsToString();
+	node->type = root.type;
+	node->name = root.GetName();
+	node->extra_info = root.ParamsToString();
 	node->depth = depth;
-	tree_map[root] = node.get();
-	auto children = root->GetChildren();
+	tree_map.insert(make_pair(reference<const PhysicalOperator>(root), reference<QueryProfiler::TreeNode>(*node)));
+	auto children = root.GetChildren();
 	for (auto &child : children) {
-		auto child_node = CreateTree(child, depth + 1);
+		auto child_node = CreateTree(child.get(), depth + 1);
 		node->children.push_back(std::move(child_node));
 	}
 	return node;

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

@@ -38,13 +38,19 @@ void Executor::AddEvent(shared_ptr<Event> event) {
 }
 
 struct PipelineEventStack {
-	Event *pipeline_initialize_event;
-	Event *pipeline_event;
-	Event *pipeline_finish_event;
-	Event *pipeline_complete_event;
+	PipelineEventStack(Event &pipeline_initialize_event, Event &pipeline_event, Event &pipeline_finish_event,
+	                   Event &pipeline_complete_event)
+	    : pipeline_initialize_event(pipeline_initialize_event), pipeline_event(pipeline_event),
+	      pipeline_finish_event(pipeline_finish_event), pipeline_complete_event(pipeline_complete_event) {
+	}
+
+	Event &pipeline_initialize_event;
+	Event &pipeline_event;
+	Event &pipeline_finish_event;
+	Event &pipeline_complete_event;
 };
 
-using event_map_t = unordered_map<const Pipeline *, PipelineEventStack>;
+using event_map_t = reference_map_t<Pipeline, PipelineEventStack>;
 
 struct ScheduleEventData {
 	ScheduleEventData(const vector<shared_ptr<MetaPipeline>> &meta_pipelines, vector<shared_ptr<Event>> &events,
@@ -69,17 +75,16 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 	auto base_event = make_shared<PipelineEvent>(base_pipeline);
 	auto base_finish_event = make_shared<PipelineFinishEvent>(base_pipeline);
 	auto base_complete_event = make_shared<PipelineCompleteEvent>(base_pipeline->executor, event_data.initial_schedule);
-	PipelineEventStack base_stack {base_initialize_event.get(), base_event.get(), base_finish_event.get(),
-	                               base_complete_event.get()};
+	PipelineEventStack base_stack(*base_initialize_event, *base_event, *base_finish_event, *base_complete_event);
 	events.push_back(std::move(base_initialize_event));
 	events.push_back(std::move(base_event));
 	events.push_back(std::move(base_finish_event));
 	events.push_back(std::move(base_complete_event));
 
 	// dependencies: initialize -> event -> finish -> complete
-	base_stack.pipeline_event->AddDependency(*base_stack.pipeline_initialize_event);
-	base_stack.pipeline_finish_event->AddDependency(*base_stack.pipeline_event);
-	base_stack.pipeline_complete_event->AddDependency(*base_stack.pipeline_finish_event);
+	base_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
+	base_stack.pipeline_finish_event.AddDependency(base_stack.pipeline_event);
+	base_stack.pipeline_complete_event.AddDependency(base_stack.pipeline_finish_event);
 
 	// create an event and stack for all pipelines in the MetaPipeline
 	vector<shared_ptr<Pipeline>> pipelines;
@@ -90,30 +95,30 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 
 		// create events/stack for this pipeline
 		auto pipeline_event = make_shared<PipelineEvent>(pipeline);
-		Event *pipeline_finish_event_ptr;
+		optional_ptr<Event> pipeline_finish_event_ptr;
 		if (meta_pipeline->HasFinishEvent(pipeline.get())) {
 			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
 			auto pipeline_finish_event = make_shared<PipelineFinishEvent>(pipeline);
 			pipeline_finish_event_ptr = pipeline_finish_event.get();
 			events.push_back(std::move(pipeline_finish_event));
-			base_stack.pipeline_complete_event->AddDependency(*pipeline_finish_event_ptr);
+			base_stack.pipeline_complete_event.AddDependency(*pipeline_finish_event_ptr);
 		} else {
-			pipeline_finish_event_ptr = base_stack.pipeline_finish_event;
+			pipeline_finish_event_ptr = &base_stack.pipeline_finish_event;
 		}
-		PipelineEventStack pipeline_stack {base_stack.pipeline_initialize_event, pipeline_event.get(),
-		                                   pipeline_finish_event_ptr, base_stack.pipeline_complete_event};
+		PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
+		                                  *pipeline_finish_event_ptr, base_stack.pipeline_complete_event);
 		events.push_back(std::move(pipeline_event));
 
 		// dependencies: base_initialize -> pipeline_event -> base_finish
-		pipeline_stack.pipeline_event->AddDependency(*base_stack.pipeline_initialize_event);
-		pipeline_stack.pipeline_finish_event->AddDependency(*pipeline_stack.pipeline_event);
+		pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
+		pipeline_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
 
 		// add pipeline stack to event map
-		event_map.insert(make_pair(pipeline.get(), pipeline_stack));
+		event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
 	}
 
 	// add base stack to the event data too
-	event_map.insert(make_pair(base_pipeline.get(), base_stack));
+	event_map.insert(make_pair(reference<Pipeline>(*base_pipeline), base_stack));
 
 	// set up the dependencies within this MetaPipeline
 	for (auto &pipeline : pipelines) {
@@ -128,10 +133,14 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 		if (!dependencies) {
 			continue;
 		}
-		auto &pipeline_stack = event_map[pipeline.get()];
+		auto root_entry = event_map.find(*pipeline);
+		D_ASSERT(root_entry != event_map.end());
+		auto &pipeline_stack = root_entry->second;
 		for (auto &dependency : *dependencies) {
-			auto &dependency_stack = event_map[dependency];
-			pipeline_stack.pipeline_event->AddDependency(*dependency_stack.pipeline_event);
+			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);
 		}
 	}
 }
@@ -148,15 +157,14 @@ void Executor::ScheduleEventsInternal(ScheduleEventData &event_data) {
 	// set up the dependencies across MetaPipelines
 	auto &event_map = event_data.event_map;
 	for (auto &entry : event_map) {
-		auto pipeline = entry.first;
-		for (auto &dependency : pipeline->dependencies) {
+		auto &pipeline = entry.first.get();
+		for (auto &dependency : pipeline.dependencies) {
 			auto dep = dependency.lock();
 			D_ASSERT(dep);
-			auto event_map_entry = event_map.find(dep.get());
+			auto event_map_entry = event_map.find(*dep);
 			D_ASSERT(event_map_entry != event_map.end());
 			auto &dep_entry = event_map_entry->second;
-			D_ASSERT(dep_entry.pipeline_complete_event);
-			entry.second.pipeline_event->AddDependency(*dep_entry.pipeline_complete_event);
+			entry.second.pipeline_event.AddDependency(dep_entry.pipeline_complete_event);
 		}
 	}
 
@@ -231,7 +239,7 @@ void Executor::VerifyScheduledEventsInternal(const idx_t vertex, const vector<Ev
 	recursion_stack[vertex] = false;
 }
 
-void Executor::AddRecursiveCTE(PhysicalOperator *rec_cte) {
+void Executor::AddRecursiveCTE(PhysicalOperator &rec_cte) {
 	recursive_ctes.push_back(rec_cte);
 }
 
@@ -258,8 +266,8 @@ void Executor::VerifyPipeline(Pipeline &pipeline) {
 		auto other_operators = other_pipeline->GetOperators();
 		for (idx_t op_idx = 0; op_idx < operators.size(); op_idx++) {
 			for (idx_t other_idx = 0; other_idx < other_operators.size(); other_idx++) {
-				auto &left = *operators[op_idx];
-				auto &right = *other_operators[other_idx];
+				auto &left = operators[op_idx].get();
+				auto &right = other_operators[other_idx].get();
 				if (left.Equals(right)) {
 					D_ASSERT(right.Equals(left));
 				} else {
@@ -281,23 +289,23 @@ void Executor::VerifyPipelines() {
 void Executor::Initialize(unique_ptr<PhysicalOperator> physical_plan) {
 	Reset();
 	owned_plan = std::move(physical_plan);
-	InitializeInternal(owned_plan.get());
+	InitializeInternal(*owned_plan);
 }
 
-void Executor::Initialize(PhysicalOperator *plan) {
+void Executor::Initialize(PhysicalOperator &plan) {
 	Reset();
 	InitializeInternal(plan);
 }
 
-void Executor::InitializeInternal(PhysicalOperator *plan) {
+void Executor::InitializeInternal(PhysicalOperator &plan) {
 
 	auto &scheduler = TaskScheduler::GetScheduler(context);
 	{
 		lock_guard<mutex> elock(executor_lock);
-		physical_plan = plan;
+		physical_plan = &plan;
 
 		this->profiler = ClientData::Get(context).profiler;
-		profiler->Initialize(physical_plan);
+		profiler->Initialize(plan);
 		this->producer = scheduler.CreateProducer();
 
 		// build and ready the pipelines
@@ -307,10 +315,9 @@ void Executor::InitializeInternal(PhysicalOperator *plan) {
 		root_pipeline->Ready();
 
 		// ready recursive cte pipelines too
-		for (auto &rec_cte : recursive_ctes) {
-			D_ASSERT(rec_cte->type == PhysicalOperatorType::RECURSIVE_CTE);
-			auto &rec_cte_op = (PhysicalRecursiveCTE &)*rec_cte;
-			rec_cte_op.recursive_meta_pipeline->Ready();
+		for (auto &rec_cte_ref : recursive_ctes) {
+			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
+			rec_cte.recursive_meta_pipeline->Ready();
 		}
 
 		// set root pipelines, i.e., all pipelines that end in the final sink
@@ -346,9 +353,8 @@ void Executor::CancelTasks() {
 		for (auto &pipeline : pipelines) {
 			weak_references.push_back(weak_ptr<Pipeline>(pipeline));
 		}
-		for (auto op : recursive_ctes) {
-			D_ASSERT(op->type == PhysicalOperatorType::RECURSIVE_CTE);
-			auto &rec_cte = (PhysicalRecursiveCTE &)*op;
+		for (auto &rec_cte_ref : recursive_ctes) {
+			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
 			rec_cte.recursive_meta_pipeline.reset();
 		}
 		pipelines.clear();
@@ -441,18 +447,18 @@ void Executor::Reset() {
 	execution_result = PendingExecutionResult::RESULT_NOT_READY;
 }
 
-shared_ptr<Pipeline> Executor::CreateChildPipeline(Pipeline *current, PhysicalOperator *op) {
-	D_ASSERT(!current->operators.empty());
-	D_ASSERT(op->IsSource());
+shared_ptr<Pipeline> Executor::CreateChildPipeline(Pipeline &current, PhysicalOperator &op) {
+	D_ASSERT(!current.operators.empty());
+	D_ASSERT(op.IsSource());
 	// found another operator that is a source, schedule a child pipeline
 	// 'op' is the source, and the sink is the same
 	auto child_pipeline = make_shared<Pipeline>(*this);
-	child_pipeline->sink = current->sink;
-	child_pipeline->source = op;
+	child_pipeline->sink = current.sink;
+	child_pipeline->source = &op;
 
 	// the child pipeline has the same operators up until 'op'
-	for (auto current_op : current->operators) {
-		if (current_op == op) {
+	for (auto current_op : current.operators) {
+		if (&current_op.get() == &op) {
 			break;
 		}
 		child_pipeline->operators.push_back(current_op);

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

@@ -18,7 +18,7 @@ PipelineBuildState &MetaPipeline::GetState() const {
 	return state;
 }
 
-PhysicalOperator *MetaPipeline::GetSink() const {
+optional_ptr<PhysicalOperator> MetaPipeline::GetSink() const {
 	return sink;
 }
 
@@ -83,14 +83,14 @@ void MetaPipeline::Ready() {
 	}
 }
 
-MetaPipeline *MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator *op) {
-	children.push_back(make_shared<MetaPipeline>(executor, state, op));
+MetaPipeline &MetaPipeline::CreateChildMetaPipeline(Pipeline &current, PhysicalOperator &op) {
+	children.push_back(make_shared<MetaPipeline>(executor, state, &op));
 	auto child_meta_pipeline = children.back().get();
 	// child MetaPipeline must finish completely before this MetaPipeline can start
 	current.AddDependency(child_meta_pipeline->GetBasePipeline());
 	// child meta pipeline is part of the recursive CTE too
 	child_meta_pipeline->recursive_cte = recursive_cte;
-	return child_meta_pipeline;
+	return *child_meta_pipeline;
 }
 
 Pipeline *MetaPipeline::CreatePipeline() {
@@ -153,7 +153,7 @@ Pipeline *MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matter
 	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);