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

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -141,7 +141,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 }
 
 void ResultArrowArrayStreamWrapper::MyStreamRelease(struct ArrowArrayStream *stream) {
-	if (!stream->release) {
+	if (!stream || !stream->release) {
 		return;
 	}
 	stream->release = nullptr;

package/src/duckdb/src/common/tree_renderer.cpp

@@ -403,10 +403,10 @@ void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
 }
 
 struct PipelineRenderNode {
-	explicit PipelineRenderNode(PhysicalOperator &op) : op(op) {
+	explicit PipelineRenderNode(const PhysicalOperator &op) : op(op) {
 	}
 
-	PhysicalOperator &op;
+	const PhysicalOperator &op;
 	unique_ptr<PipelineRenderNode> child;
 };
 
@@ -542,7 +542,7 @@ unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &op) {
 	D_ASSERT(!operators.empty());
 	unique_ptr<PipelineRenderNode> node;
 	for (auto &op : operators) {
-		auto new_node = make_uniq<PipelineRenderNode>(*op);
+		auto new_node = make_uniq<PipelineRenderNode>(op.get());
 		new_node->child = std::move(node);
 		node = std::move(new_node);
 	}

package/src/duckdb/src/common/types/conflict_manager.cpp

@@ -5,7 +5,8 @@
 
 namespace duckdb {
 
-ConflictManager::ConflictManager(VerifyExistenceType lookup_type, idx_t input_size, ConflictInfo *conflict_info)
+ConflictManager::ConflictManager(VerifyExistenceType lookup_type, idx_t input_size,
+                                 optional_ptr<ConflictInfo> conflict_info)
     : lookup_type(lookup_type), input_size(input_size), conflict_info(conflict_info), conflicts(input_size, false),
       mode(ConflictManagerMode::THROW) {
 }

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -80,7 +80,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		if (insert_op.action_type != OnConflictAction::THROW) {
 			// Get the bindings from the children
 			VisitOperatorChildren(op);
-			auto column_count = insert_op.table->GetColumns().PhysicalColumnCount();
+			auto column_count = insert_op.table.GetColumns().PhysicalColumnCount();
 			auto dummy_bindings = LogicalOperator::GenerateColumnBindings(insert_op.excluded_table_index, column_count);
 			// Now insert our dummy bindings at the start of the bindings,
 			// so the first 'column_count' indices of the chunk are reserved for our 'excluded' columns

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

@@ -342,7 +342,7 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 	}
 
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &source.child_executor, "child_executor", 0);
+	context.thread.profiler.Flush(*this, source.child_executor, "child_executor", 0);
 	client_profiler.Flush(context.thread.profiler);
 }
 

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

@@ -30,8 +30,8 @@ public:
 	SelectionVector sel;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &executor, "filter", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, executor, "filter", 0);
 	}
 };
 

package/src/duckdb/src/execution/operator/helper/physical_execute.cpp

@@ -8,8 +8,8 @@ PhysicalExecute::PhysicalExecute(PhysicalOperator &plan)
     : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan.types, -1), plan(plan) {
 }
 
-vector<PhysicalOperator *> PhysicalExecute::GetChildren() const {
-	return {&plan};
+vector<const_reference<PhysicalOperator>> PhysicalExecute::GetChildren() const {
+	return {plan};
 }
 
 void PhysicalExecute::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {

package/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp

@@ -31,8 +31,8 @@ unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(
 	}
 }
 
-vector<PhysicalOperator *> PhysicalResultCollector::GetChildren() const {
-	return {&plan};
+vector<const_reference<PhysicalOperator>> PhysicalResultCollector::GetChildren() const {
+	return {plan};
 }
 
 void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) {
@@ -43,11 +43,11 @@ void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &me
 
 	// single operator: the operator becomes the data source of the current pipeline
 	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 
 	// we create a new pipeline starting from the child
-	auto child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	child_meta_pipeline->Build(plan);
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	child_meta_pipeline.Build(plan);
 }
 
 } // namespace duckdb

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

@@ -140,7 +140,7 @@ void PhysicalCrossProduct::BuildPipelines(Pipeline &current, MetaPipeline &meta_
 	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
 }
 
-vector<const PhysicalOperator *> PhysicalCrossProduct::GetSources() const {
+vector<const_reference<PhysicalOperator>> PhysicalCrossProduct::GetSources() const {
 	return children[0]->GetSources();
 }
 

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

@@ -12,7 +12,7 @@
 namespace duckdb {
 
 PhysicalDelimJoin::PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
-                                     vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality)
+                                     vector<const_reference<PhysicalOperator>> delim_scans, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::DELIM_JOIN, std::move(types), estimated_cardinality),
       join(std::move(original_join)), delim_scans(std::move(delim_scans)) {
 	D_ASSERT(join->children.size() == 2);
@@ -27,13 +27,13 @@ PhysicalDelimJoin::PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<Physi
 	join->children[0] = std::move(cached_chunk_scan);
 }
 
-vector<PhysicalOperator *> PhysicalDelimJoin::GetChildren() const {
-	vector<PhysicalOperator *> result;
+vector<const_reference<PhysicalOperator>> PhysicalDelimJoin::GetChildren() const {
+	vector<const_reference<PhysicalOperator>> result;
 	for (auto &child : children) {
-		result.push_back(child.get());
+		result.push_back(*child);
 	}
-	result.push_back(join.get());
-	result.push_back(distinct.get());
+	result.push_back(*join);
+	result.push_back(*distinct);
 	return result;
 }
 
@@ -46,7 +46,7 @@ public:
 	    : lhs_data(context, delim_join.children[0]->GetTypes()) {
 		D_ASSERT(delim_join.delim_scans.size() > 0);
 		// set up the delim join chunk to scan in the original join
-		auto &cached_chunk_scan = (PhysicalColumnDataScan &)*delim_join.join->children[0];
+		auto &cached_chunk_scan = delim_join.join->children[0]->Cast<PhysicalColumnDataScan>();
 		cached_chunk_scan.collection = &lhs_data;
 	}
 
@@ -124,8 +124,8 @@ void PhysicalDelimJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pip
 	op_state.reset();
 	sink_state.reset();
 
-	auto child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	child_meta_pipeline->Build(*children[0]);
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	child_meta_pipeline.Build(*children[0]);
 
 	if (type == PhysicalOperatorType::DELIM_JOIN) {
 		// recurse into the actual join
@@ -134,7 +134,8 @@ void PhysicalDelimJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pip
 		// we add an entry to the mapping of (PhysicalOperator*) -> (Pipeline*)
 		auto &state = meta_pipeline.GetState();
 		for (auto &delim_scan : delim_scans) {
-			state.delim_join_dependencies[delim_scan] = child_meta_pipeline->GetBasePipeline().get();
+			state.delim_join_dependencies.insert(
+			    make_pair(delim_scan, reference<Pipeline>(*child_meta_pipeline.GetBasePipeline())));
 		}
 		join->BuildPipelines(current, meta_pipeline);
 	}

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

@@ -220,7 +220,7 @@ void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstat
 		gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
 	}
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &lstate.build_executor, "build_executor", 1);
+	context.thread.profiler.Flush(*this, lstate.build_executor, "build_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
@@ -429,8 +429,8 @@ public:
 	DataChunk spill_chunk;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &probe_executor, "probe_executor", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, probe_executor, "probe_executor", 0);
 	}
 };
 

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

@@ -150,7 +150,7 @@ void PhysicalIEJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 	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, lstate.table.executor, gstate.child ? "rhs_executor" : "lhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
@@ -1011,24 +1011,24 @@ void PhysicalIEJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeli
 	}
 
 	// becomes a source after both children fully sink their data
-	meta_pipeline.GetState().SetPipelineSource(current, this);
+	meta_pipeline.GetState().SetPipelineSource(current, *this);
 
 	// Create one child meta pipeline that will hold the LHS and RHS pipelines
-	auto child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	auto lhs_pipeline = child_meta_pipeline->GetBasePipeline();
-	auto rhs_pipeline = child_meta_pipeline->CreatePipeline();
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	auto lhs_pipeline = child_meta_pipeline.GetBasePipeline();
+	auto rhs_pipeline = child_meta_pipeline.CreatePipeline();
 
 	// Build out LHS
-	children[0]->BuildPipelines(*lhs_pipeline, *child_meta_pipeline);
+	children[0]->BuildPipelines(*lhs_pipeline, child_meta_pipeline);
 
 	// RHS depends on everything in LHS
-	child_meta_pipeline->AddDependenciesFrom(rhs_pipeline, lhs_pipeline.get(), true);
+	child_meta_pipeline.AddDependenciesFrom(rhs_pipeline, lhs_pipeline.get(), true);
 
 	// Build out RHS
-	children[1]->BuildPipelines(*rhs_pipeline, *child_meta_pipeline);
+	children[1]->BuildPipelines(*rhs_pipeline, child_meta_pipeline);
 
 	// Despite having the same sink, RHS needs its own PipelineFinishEvent
-	child_meta_pipeline->AddFinishEvent(rhs_pipeline);
+	child_meta_pipeline.AddFinishEvent(rhs_pipeline);
 }
 
 } // namespace duckdb

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

@@ -52,8 +52,8 @@ public:
 	unique_ptr<ColumnFetchState> fetch_state;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &probe_executor, "probe_executor", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, probe_executor, "probe_executor", 0);
 	}
 };
 
@@ -229,11 +229,11 @@ void PhysicalIndexJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pip
 	// index join: we only continue into the LHS
 	// the right side is probed by the index join
 	// so we don't need to do anything in the pipeline with this child
-	meta_pipeline.GetState().AddPipelineOperator(current, this);
+	meta_pipeline.GetState().AddPipelineOperator(current, *this);
 	children[0]->BuildPipelines(current, meta_pipeline);
 }
 
-vector<const PhysicalOperator *> PhysicalIndexJoin::GetSources() const {
+vector<const_reference<PhysicalOperator>> PhysicalIndexJoin::GetSources() const {
 	return children[0]->GetSources();
 }
 

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

@@ -32,7 +32,7 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 
 	// 'current' is the probe pipeline: add this operator
 	auto &state = meta_pipeline.GetState();
-	state.AddPipelineOperator(current, &op);
+	state.AddPipelineOperator(current, op);
 
 	// save the last added pipeline to set up dependencies later (in case we need to add a child pipeline)
 	vector<shared_ptr<Pipeline>> pipelines_so_far;
@@ -40,8 +40,8 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	auto last_pipeline = pipelines_so_far.back().get();
 
 	// 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);
-	child_meta_pipeline->Build(*op.children[1]);
+	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, op);
+	child_meta_pipeline.Build(*op.children[1]);
 
 	// continue building the current pipeline on the LHS (probe side)
 	op.children[0]->BuildPipelines(current, meta_pipeline);
@@ -49,7 +49,7 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	switch (op.type) {
 	case PhysicalOperatorType::POSITIONAL_JOIN:
 		// Positional joins are always outer
-		meta_pipeline.CreateChildPipeline(current, &op, last_pipeline);
+		meta_pipeline.CreateChildPipeline(current, op, last_pipeline);
 		return;
 	case PhysicalOperatorType::CROSS_PRODUCT:
 		return;
@@ -65,7 +65,7 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	}
 
 	if (add_child_pipeline) {
-		meta_pipeline.CreateChildPipeline(current, &op, last_pipeline);
+		meta_pipeline.CreateChildPipeline(current, op, last_pipeline);
 	}
 }
 
@@ -73,10 +73,10 @@ void PhysicalJoin::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline
 	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
 }
 
-vector<const PhysicalOperator *> PhysicalJoin::GetSources() const {
+vector<const_reference<PhysicalOperator>> PhysicalJoin::GetSources() const {
 	auto result = children[0]->GetSources();
 	if (IsSource()) {
-		result.push_back(this);
+		result.push_back(*this);
 	}
 	return result;
 }

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

@@ -195,7 +195,7 @@ void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState
 	auto &state = lstate.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, state.rhs_executor, "rhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
@@ -255,8 +255,8 @@ public:
 	OuterJoinMarker left_outer;
 
 public:
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &lhs_executor, "lhs_executor", 0);
+	void Finalize(const PhysicalOperator &op, ExecutionContext &context) override {
+		context.thread.profiler.Flush(op, lhs_executor, "lhs_executor", 0);
 	}
 };
 

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

@@ -125,7 +125,7 @@ void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkSt
 	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, lstate.table.executor, "rhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
@@ -245,9 +245,9 @@ public:
 		lhs_local_table->executor.Execute(lhs_payload, lhs_local_table->keys);
 	}
 
-	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
+	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, lhs_local_table->executor, "lhs_executor", 0);
 		}
 	}
 };

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

@@ -183,10 +183,10 @@ void PhysicalPositionalJoin::BuildPipelines(Pipeline &current, MetaPipeline &met
 	PhysicalJoin::BuildJoinPipelines(current, meta_pipeline, *this);
 }
 
-vector<const PhysicalOperator *> PhysicalPositionalJoin::GetSources() const {
+vector<const_reference<PhysicalOperator>> PhysicalPositionalJoin::GetSources() const {
 	auto result = children[0]->GetSources();
 	if (IsSource()) {
-		result.push_back(this);
+		result.push_back(*this);
 	}
 	return result;
 }

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

@@ -65,8 +65,8 @@ void BufferedCSVReaderOptions::SetHeader(bool input) {
 	this->has_header = true;
 }
 
-void BufferedCSVReaderOptions::SetCompression(const string &compression) {
-	this->compression = FileCompressionTypeFromString(compression);
+void BufferedCSVReaderOptions::SetCompression(const string &compression_p) {
+	this->compression = FileCompressionTypeFromString(compression_p);
 }
 
 void BufferedCSVReaderOptions::SetEscape(const string &input) {
@@ -82,8 +82,8 @@ void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
 	}
 }
 
-void BufferedCSVReaderOptions::SetQuote(const string &quote) {
-	this->quote = quote;
+void BufferedCSVReaderOptions::SetQuote(const string &quote_p) {
+	this->quote = quote_p;
 	this->has_quote = true;
 }
 
@@ -101,12 +101,10 @@ void BufferedCSVReaderOptions::SetNewline(const string &input) {
 void BufferedCSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, bool read_format) {
 	string error;
 	if (read_format) {
-		auto &date_format = this->date_format[type];
-		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
-		date_format.format_specifier = format;
+		error = StrTimeFormat::ParseFormatSpecifier(format, date_format[type]);
+		date_format[type].format_specifier = format;
 	} else {
-		auto &date_format = this->write_date_format[type];
-		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
+		error = StrTimeFormat::ParseFormatSpecifier(format, write_date_format[type]);
 	}
 	if (!error.empty()) {
 		throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
@@ -198,6 +196,7 @@ void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value
 			format = "%Y-%m-%dT%H:%M:%S.%fZ";
 		}
 		SetDateFormat(LogicalTypeId::TIMESTAMP, format, false);
+		SetDateFormat(LogicalTypeId::TIMESTAMP_TZ, format, false);
 	} else {
 		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
 	}

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

@@ -11,11 +11,11 @@
 
 namespace duckdb {
 
-PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry *table,
+PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry &table,
                                          physical_index_vector_t<idx_t> column_index_map,
                                          vector<unique_ptr<Expression>> bound_defaults, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::BATCH_INSERT, std::move(types), estimated_cardinality),
-      column_index_map(std::move(column_index_map)), insert_table(table), insert_types(table->GetTypes()),
+      column_index_map(std::move(column_index_map)), insert_table(&table), insert_types(table.GetTypes()),
       bound_defaults(std::move(bound_defaults)) {
 }
 
@@ -96,11 +96,11 @@ public:
 
 class BatchInsertGlobalState : public GlobalSinkState {
 public:
-	explicit BatchInsertGlobalState() : insert_count(0) {
+	explicit BatchInsertGlobalState(DuckTableEntry &table) : table(table), insert_count(0) {
 	}
 
 	mutex lock;
-	optional_ptr<DuckTableEntry> table;
+	DuckTableEntry &table;
 	idx_t insert_count;
 	map<idx_t, unique_ptr<RowGroupCollection>> collections;
 
@@ -265,18 +265,19 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContext &context) const {
-	auto result = make_uniq<BatchInsertGlobalState>();
+	optional_ptr<TableCatalogEntry> table;
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table = (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context),
-		                                                      *schema.get_mutable(), info.get());
+		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
+		                                                 info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
-		result->table = (DuckTableEntry *)insert_table;
+		table = insert_table.get_mutable();
 	}
+	auto result = make_uniq<BatchInsertGlobalState>(table->Cast<DuckTableEntry>());
 	return std::move(result);
 }
 
@@ -289,14 +290,14 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 	auto &gstate = state.Cast<BatchInsertGlobalState>();
 	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 
-	auto table = gstate.table;
-	PhysicalInsert::ResolveDefaults(*table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	auto &table = gstate.table;
+	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!lstate.current_collection) {
 		lock_guard<mutex> l(gstate.lock);
 		// no collection yet: create a new one
-		lstate.CreateNewCollection(*table, insert_types);
-		lstate.writer = gstate.table->GetStorage().CreateOptimisticWriter(context.client);
+		lstate.CreateNewCollection(table, insert_types);
+		lstate.writer = &table.GetStorage().CreateOptimisticWriter(context.client);
 	} else if (lstate.current_index != lstate.batch_index) {
 		// batch index has changed: move the old collection to the global state and create a new collection
 		TransactionData tdata(0, 0);
@@ -304,11 +305,11 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 		lstate.FlushToDisk();
 		gstate.AddCollection(context.client, lstate.current_index, std::move(lstate.current_collection), lstate.writer,
 		                     &lstate.written_to_disk);
-		lstate.CreateNewCollection(*table, insert_types);
+		lstate.CreateNewCollection(table, insert_types);
 	}
 	lstate.current_index = lstate.batch_index;
 
-	table->GetStorage().VerifyAppendConstraints(*table, context.client, lstate.insert_chunk);
+	table.GetStorage().VerifyAppendConstraints(table, context.client, lstate.insert_chunk);
 
 	auto new_row_group = lstate.current_collection->Append(lstate.insert_chunk, lstate.current_append_state);
 	if (new_row_group) {
@@ -323,7 +324,7 @@ void PhysicalBatchInsert::Combine(ExecutionContext &context, GlobalSinkState &gs
 	auto &gstate = gstate_p.Cast<BatchInsertGlobalState>();
 	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &lstate.default_executor, "default_executor", 1);
+	context.thread.profiler.Flush(*this, lstate.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 
 	if (!lstate.current_collection) {
@@ -346,7 +347,7 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event,
 	vector<unique_ptr<CollectionMerger>> mergers;
 	unique_ptr<CollectionMerger> current_merger;
 
-	auto &storage = gstate.table->GetStorage();
+	auto &storage = gstate.table.GetStorage();
 	for (auto &collection : gstate.collections) {
 		if (collection.second->GetTotalRows() < LocalStorage::MERGE_THRESHOLD) {
 			// this collection has very few rows: add it to the merge set
@@ -374,11 +375,11 @@ SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event,
 	// now that we have created all of the mergers, perform the actual merging
 	vector<unique_ptr<RowGroupCollection>> final_collections;
 	final_collections.reserve(mergers.size());
-	auto writer = storage.CreateOptimisticWriter(context);
+	auto &writer = storage.CreateOptimisticWriter(context);
 	for (auto &merger : mergers) {
-		final_collections.push_back(merger->Flush(*writer));
+		final_collections.push_back(merger->Flush(writer));
 	}
-	writer->FinalFlush();
+	writer.FinalFlush();
 
 	// finally, merge the row groups into the local storage
 	for (auto &collection : final_collections) {

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

@@ -197,15 +197,15 @@ void PhysicalExport::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeli
 	// EXPORT has an optional child
 	// we only need to schedule child pipelines if there is a child
 	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 	if (children.empty()) {
 		return;
 	}
 	PhysicalOperator::BuildPipelines(current, meta_pipeline);
 }
 
-vector<const PhysicalOperator *> PhysicalExport::GetSources() const {
-	return {this};
+vector<const_reference<PhysicalOperator>> PhysicalExport::GetSources() const {
+	return {*this};
 }
 
 } // namespace duckdb