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

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

@@ -20,7 +20,7 @@
 
 namespace duckdb {
 
-PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *table,
+PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry &table,
                                physical_index_vector_t<idx_t> column_index_map,
                                vector<unique_ptr<Expression>> bound_defaults,
                                vector<unique_ptr<Expression>> set_expressions, vector<PhysicalIndex> set_columns,
@@ -30,7 +30,7 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
                                unique_ptr<Expression> do_update_condition_p, unordered_set<column_t> conflict_target_p,
                                vector<column_t> columns_to_fetch_p)
     : PhysicalOperator(PhysicalOperatorType::INSERT, std::move(types_p), 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)), return_chunk(return_chunk), parallel(parallel),
       action_type(action_type), set_expressions(std::move(set_expressions)), set_columns(std::move(set_columns)),
       set_types(std::move(set_types)), on_conflict_condition(std::move(on_conflict_condition_p)),
@@ -75,12 +75,12 @@ void PhysicalInsert::GetInsertInfo(const BoundCreateTableInfo &info, vector<Logi
 //===--------------------------------------------------------------------===//
 class InsertGlobalState : public GlobalSinkState {
 public:
-	explicit InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types)
-	    : insert_count(0), initialized(false), return_collection(context, return_types) {
+	explicit InsertGlobalState(ClientContext &context, const vector<LogicalType> &return_types, DuckTableEntry &table)
+	    : table(table), insert_count(0), initialized(false), return_collection(context, return_types) {
 	}
 
 	mutex lock;
-	optional_ptr<DuckTableEntry> table;
+	DuckTableEntry &table;
 	idx_t insert_count;
 	bool initialized;
 	LocalAppendState append_state;
@@ -105,18 +105,19 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
-	auto result = make_uniq<InsertGlobalState>(context, GetTypes());
+	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<InsertGlobalState>(context, GetTypes(), table->Cast<DuckTableEntry>());
 	return std::move(result);
 }
 
@@ -357,9 +358,9 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 	auto &gstate = state.Cast<InsertGlobalState>();
 	auto &lstate = lstate_p.Cast<InsertLocalState>();
 
-	auto table = gstate.table;
-	auto &storage = table->GetStorage();
-	PhysicalInsert::ResolveDefaults(*table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	auto &table = gstate.table;
+	auto &storage = table.GetStorage();
+	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!parallel) {
 		if (!gstate.initialized) {
@@ -367,8 +368,8 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			gstate.initialized = true;
 		}
 
-		OnConflictHandling(*table, context, lstate);
-		storage.LocalAppend(gstate.append_state, *table, context.client, lstate.insert_chunk, true);
+		OnConflictHandling(table, context, lstate);
+		storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
 			gstate.return_collection.Append(lstate.insert_chunk);
@@ -385,9 +386,9 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			    make_uniq<RowGroupCollection>(table_info, block_manager, insert_types, MAX_ROW_ID);
 			lstate.local_collection->InitializeEmpty();
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
-			lstate.writer = gstate.table->GetStorage().CreateOptimisticWriter(context.client);
+			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
 		}
-		OnConflictHandling(*table, context, lstate);
+		OnConflictHandling(table, context, lstate);
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
 		if (new_row_group) {
 			lstate.writer->CheckFlushToDisk(*lstate.local_collection);
@@ -401,7 +402,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 	auto &gstate = gstate_p.Cast<InsertGlobalState>();
 	auto &lstate = lstate_p.Cast<InsertLocalState>();
 	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 (!parallel) {
@@ -420,12 +421,12 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		// we have few rows - append to the local storage directly
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
-		auto table = gstate.table;
-		auto &storage = table->GetStorage();
+		auto &table = gstate.table;
+		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
-		auto &transaction = DuckTransaction::Get(context.client, *table->catalog);
+		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
 		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
-			storage.LocalAppend(gstate.append_state, *table, context.client, insert_chunk);
+			storage.LocalAppend(gstate.append_state, table, context.client, insert_chunk);
 			return true;
 		});
 		storage.FinalizeLocalAppend(gstate.append_state);
@@ -437,7 +438,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
-		gstate.table->GetStorage().LocalMerge(context.client, *lstate.local_collection);
+		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
 	}
 }
 
@@ -445,8 +446,8 @@ SinkFinalizeType PhysicalInsert::Finalize(Pipeline &pipeline, Event &event, Clie
                                           GlobalSinkState &state) const {
 	auto &gstate = state.Cast<InsertGlobalState>();
 	if (!parallel && gstate.initialized) {
-		auto table = gstate.table;
-		auto &storage = table->GetStorage();
+		auto &table = gstate.table;
+		auto &storage = table.GetStorage();
 		storage.FinalizeLocalAppend(gstate.append_state);
 	}
 	return SinkFinalizeType::READY;

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

@@ -144,7 +144,7 @@ unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &c
 void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = lstate.Cast<UpdateLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
-	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
+	context.thread.profiler.Flush(*this, state.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 

package/src/duckdb/src/execution/operator/projection/physical_projection.cpp

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

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

@@ -6,6 +6,13 @@
 
 namespace duckdb {
 
+PhysicalColumnDataScan::PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type,
+                                               idx_t estimated_cardinality,
+                                               unique_ptr<ColumnDataCollection> owned_collection_p)
+    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(owned_collection_p.get()),
+      owned_collection(std::move(owned_collection_p)) {
+}
+
 class PhysicalColumnDataScanState : public GlobalSourceState {
 public:
 	explicit PhysicalColumnDataScanState() : initialized(false) {
@@ -23,7 +30,6 @@ unique_ptr<GlobalSourceState> PhysicalColumnDataScan::GetGlobalSourceState(Clien
 void PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                      LocalSourceState &lstate) const {
 	auto &state = gstate.Cast<PhysicalColumnDataScanState>();
-	D_ASSERT(collection);
 	if (collection->Count() == 0) {
 		return;
 	}
@@ -42,17 +48,17 @@ void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &met
 	auto &state = meta_pipeline.GetState();
 	switch (type) {
 	case PhysicalOperatorType::DELIM_SCAN: {
-		auto entry = state.delim_join_dependencies.find(this);
+		auto entry = state.delim_join_dependencies.find(*this);
 		D_ASSERT(entry != state.delim_join_dependencies.end());
 		// this chunk scan introduces a dependency to the current pipeline
 		// namely a dependency on the duplicate elimination pipeline to finish
-		auto delim_dependency = entry->second->shared_from_this();
+		auto delim_dependency = entry->second.get().shared_from_this();
 		auto delim_sink = state.GetPipelineSink(*delim_dependency);
 		D_ASSERT(delim_sink);
 		D_ASSERT(delim_sink->type == PhysicalOperatorType::DELIM_JOIN);
-		auto &delim_join = (PhysicalDelimJoin &)*delim_sink;
+		auto &delim_join = delim_sink->Cast<PhysicalDelimJoin>();
 		current.AddDependency(delim_dependency);
-		state.SetPipelineSource(current, (PhysicalOperator *)delim_join.distinct.get());
+		state.SetPipelineSource(current, (PhysicalOperator &)*delim_join.distinct);
 		return;
 	}
 	case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
@@ -64,7 +70,7 @@ void PhysicalColumnDataScan::BuildPipelines(Pipeline &current, MetaPipeline &met
 		break;
 	}
 	D_ASSERT(children.empty());
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp

@@ -130,13 +130,12 @@ void PhysicalRecursiveCTE::ExecuteRecursivePipelines(ExecutionContext &context)
 	recursive_meta_pipeline->GetPipelines(pipelines, true);
 	for (auto &pipeline : pipelines) {
 		auto sink = pipeline->GetSink();
-		if (sink != this) {
+		if (sink.get() != this) {
 			sink->sink_state.reset();
 		}
-		for (auto &op : pipeline->GetOperators()) {
-			if (op) {
-				op->op_state.reset();
-			}
+		for (auto &op_ref : pipeline->GetOperators()) {
+			auto &op = op_ref.get();
+			op.op_state.reset();
 		}
 		pipeline->ClearSource();
 	}
@@ -176,14 +175,14 @@ void PhysicalRecursiveCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_
 	recursive_meta_pipeline.reset();
 
 	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, this);
+	state.SetPipelineSource(current, *this);
 
 	auto &executor = meta_pipeline.GetExecutor();
-	executor.AddRecursiveCTE(this);
+	executor.AddRecursiveCTE(*this);
 
 	// the LHS of the recursive CTE is our initial state
-	auto initial_state_pipeline = meta_pipeline.CreateChildMetaPipeline(current, this);
-	initial_state_pipeline->Build(*children[0]);
+	auto &initial_state_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+	initial_state_pipeline.Build(*children[0]);
 
 	// the RHS is the recursive pipeline
 	recursive_meta_pipeline = make_shared<MetaPipeline>(executor, state, this);
@@ -191,8 +190,8 @@ void PhysicalRecursiveCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_
 	recursive_meta_pipeline->Build(*children[1]);
 }
 
-vector<const PhysicalOperator *> PhysicalRecursiveCTE::GetSources() const {
-	return {this};
+vector<const_reference<PhysicalOperator>> PhysicalRecursiveCTE::GetSources() const {
+	return {*this};
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/set/physical_union.cpp

@@ -55,8 +55,8 @@ void PhysicalUnion::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipelin
 	meta_pipeline.AssignNextBatchIndex(union_pipeline);
 }
 
-vector<const PhysicalOperator *> PhysicalUnion::GetSources() const {
-	vector<const PhysicalOperator *> result;
+vector<const_reference<PhysicalOperator>> PhysicalUnion::GetSources() const {
+	vector<const_reference<PhysicalOperator>> result;
 	for (auto &child : children) {
 		auto child_sources = child->GetSources();
 		result.insert(result.end(), child_sources.begin(), child_sources.end());

package/src/duckdb/src/execution/physical_operator.cpp

@@ -28,10 +28,10 @@ void PhysicalOperator::Print() const {
 }
 // LCOV_EXCL_STOP
 
-vector<PhysicalOperator *> PhysicalOperator::GetChildren() const {
-	vector<PhysicalOperator *> result;
+vector<const_reference<PhysicalOperator>> PhysicalOperator::GetChildren() const {
+	vector<const_reference<PhysicalOperator>> result;
 	for (auto &child : children) {
-		result.push_back(child.get());
+		result.push_back(*child);
 	}
 	return result;
 }
@@ -134,36 +134,36 @@ void PhysicalOperator::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipe
 		D_ASSERT(children.size() == 1);
 
 		// single operator: the operator becomes the data source of the current pipeline
-		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(*children[0]);
+		auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
+		child_meta_pipeline.Build(*children[0]);
 	} else {
 		// operator is not a sink! recurse in children
 		if (children.empty()) {
 			// source
-			state.SetPipelineSource(current, this);
+			state.SetPipelineSource(current, *this);
 		} else {
 			if (children.size() != 1) {
 				throw InternalException("Operator not supported in BuildPipelines");
 			}
-			state.AddPipelineOperator(current, this);
+			state.AddPipelineOperator(current, *this);
 			children[0]->BuildPipelines(current, meta_pipeline);
 		}
 	}
 }
 
-vector<const PhysicalOperator *> PhysicalOperator::GetSources() const {
-	vector<const PhysicalOperator *> result;
+vector<const_reference<PhysicalOperator>> PhysicalOperator::GetSources() const {
+	vector<const_reference<PhysicalOperator>> result;
 	if (IsSink()) {
 		D_ASSERT(children.size() == 1);
-		result.push_back(this);
+		result.push_back(*this);
 		return result;
 	} else {
 		if (children.empty()) {
 			// source
-			result.push_back(this);
+			result.push_back(*this);
 			return result;
 		} else {
 			if (children.size() != 1) {
@@ -177,7 +177,7 @@ vector<const PhysicalOperator *> PhysicalOperator::GetSources() const {
 bool PhysicalOperator::AllSourcesSupportBatchIndex() const {
 	auto sources = GetSources();
 	for (auto &source : sources) {
-		if (!source->SupportsBatchIndex()) {
+		if (!source.get().SupportsBatchIndex()) {
 			return false;
 		}
 	}

package/src/duckdb/src/execution/physical_plan/plan_column_data_get.cpp

@@ -9,10 +9,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalColumnData
 	D_ASSERT(op.collection);
 
 	// create a PhysicalChunkScan pointing towards the owned collection
-	auto chunk_scan =
-	    make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = std::move(op.collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
+	                                                    op.estimated_cardinality, std::move(op.collection));
 	return std::move(chunk_scan);
 }
 

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -23,7 +23,7 @@ static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData &bind_dat
 	auto table = bind_data.table;
 	auto &transaction = DuckTransaction::Get(context, *table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
-	if (local_storage.Find(table->GetStoragePtr())) {
+	if (local_storage.Find(table->GetStorage())) {
 		// transaction local appends: skip index join
 		return false;
 	}

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -21,10 +21,10 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
 	unique_ptr<PhysicalOperator> create;
 	if (!parallel_streaming_insert && use_batch_index) {
-		create = make_uniq<PhysicalBatchInsert>(op, *op.schema, std::move(op.info), op.estimated_cardinality);
+		create = make_uniq<PhysicalBatchInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 
 	} else {
-		create = make_uniq<PhysicalInsert>(op, *op.schema, std::move(op.info), op.estimated_cardinality,
+		create = make_uniq<PhysicalInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality,
 		                                   parallel_streaming_insert && num_threads > 1);
 	}
 
@@ -35,14 +35,14 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
 	const auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = *op.info->schema->catalog;
+	auto &catalog = *op.info->schema.catalog;
 	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-		return op.schema->catalog->PlanCreateTableAs(context, op, std::move(plan));
+		return op.schema.catalog->PlanCreateTableAs(context, op, std::move(plan));
 	} else {
-		return make_uniq<PhysicalCreateTable>(op, *op.schema, std::move(op.info), op.estimated_cardinality);
+		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 	}
 }
 

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -12,7 +12,7 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanDelete(ClientContext &context, Log
 	// get the index of the row_id column
 	auto &bound_ref = op.expressions[0]->Cast<BoundReferenceExpression>();
 
-	auto del = make_uniq<PhysicalDelete>(op.types, *op.table, op.table->GetStorage(), bound_ref.index,
+	auto del = make_uniq<PhysicalDelete>(op.types, op.table, op.table.GetStorage(), bound_ref.index,
 	                                     op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(std::move(plan));
 	return std::move(del);
@@ -25,8 +25,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(*op.table);
-	return op.table->catalog->PlanDelete(context, op, std::move(plan));
+	dependencies.AddDependency(op.table);
+	return op.table.catalog->PlanDelete(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp

@@ -10,13 +10,12 @@
 
 namespace duckdb {
 
-static void GatherDelimScans(PhysicalOperator *op, vector<PhysicalOperator *> &delim_scans) {
-	D_ASSERT(op);
-	if (op->type == PhysicalOperatorType::DELIM_SCAN) {
+static void GatherDelimScans(const PhysicalOperator &op, vector<const_reference<PhysicalOperator>> &delim_scans) {
+	if (op.type == PhysicalOperatorType::DELIM_SCAN) {
 		delim_scans.push_back(op);
 	}
-	for (auto &child : op->children) {
-		GatherDelimScans(child.get(), delim_scans);
+	for (auto &child : op.children) {
+		GatherDelimScans(*child, delim_scans);
 	}
 }
 
@@ -27,8 +26,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin
 	D_ASSERT(plan && plan->type != PhysicalOperatorType::CROSS_PRODUCT);
 	// duplicate eliminated join
 	// first gather the scans on the duplicate eliminated data set from the RHS
-	vector<PhysicalOperator *> delim_scans;
-	GatherDelimScans(plan->children[1].get(), delim_scans);
+	vector<const_reference<PhysicalOperator>> delim_scans;
+	GatherDelimScans(*plan->children[1], delim_scans);
 	if (delim_scans.empty()) {
 		// no duplicate eliminated scans in the RHS!
 		// in this case we don't need to create a delim join

package/src/duckdb/src/execution/physical_plan/plan_explain.cpp

@@ -55,10 +55,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	collection->Append(chunk);
 
 	// create a chunk scan to output the result
-	auto chunk_scan =
-	    make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = std::move(collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
+	                                                    op.estimated_cardinality, std::move(collection));
 	return std::move(chunk_scan);
 }
 

package/src/duckdb/src/execution/physical_plan/plan_insert.cpp

@@ -106,8 +106,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		D_ASSERT(op.children.size() == 1);
 		plan = CreatePlan(*op.children[0]);
 	}
-	dependencies.AddDependency(*op.table);
-	return op.table->catalog->PlanInsert(context, op, std::move(plan));
+	dependencies.AddDependency(op.table);
+	return op.table.catalog->PlanInsert(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_show_select.cpp

@@ -39,10 +39,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalShow &op)
 	collection->Append(append_state, output);
 
 	// create a chunk scan to output the result
-	auto chunk_scan =
-	    make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = std::move(collection);
-	chunk_scan->collection = chunk_scan->owned_collection.get();
+	auto chunk_scan = make_uniq<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN,
+	                                                    op.estimated_cardinality, std::move(collection));
 	return std::move(chunk_scan);
 }
 

package/src/duckdb/src/execution/physical_plan/plan_update.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> DuckCatalog::PlanUpdate(ClientContext &context, LogicalUpdate &op,
                                                      unique_ptr<PhysicalOperator> plan) {
 	auto update =
-	    make_uniq<PhysicalUpdate>(op.types, *op.table, op.table->GetStorage(), op.columns, std::move(op.expressions),
+	    make_uniq<PhysicalUpdate>(op.types, op.table, op.table.GetStorage(), op.columns, std::move(op.expressions),
 	                              std::move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
 
 	update->update_is_del_and_insert = op.update_is_del_and_insert;
@@ -22,8 +22,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(*op.table);
-	return op.table->catalog->PlanUpdate(context, op, std::move(plan));
+	dependencies.AddDependency(op.table);
+	return op.table.catalog->PlanUpdate(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/compression_config.cpp

@@ -26,8 +26,8 @@ static DefaultCompressionMethod internal_compression_methods[] = {
     {CompressionType::COMPRESSION_FSST, FSSTFun::GetFunction, FSSTFun::TypeIsSupported},
     {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
 
-static CompressionFunction *FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                    PhysicalType data_type) {
+static optional_ptr<CompressionFunction> FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
+                                                                 PhysicalType data_type) {
 	auto &functions = set.functions;
 	auto comp_entry = functions.find(type);
 	if (comp_entry != functions.end()) {
@@ -40,8 +40,8 @@ static CompressionFunction *FindCompressionFunction(CompressionFunctionSet &set,
 	return nullptr;
 }
 
-static CompressionFunction *LoadCompressionFunction(CompressionFunctionSet &set, CompressionType type,
-                                                    PhysicalType data_type) {
+static optional_ptr<CompressionFunction> LoadCompressionFunction(CompressionFunctionSet &set, CompressionType type,
+                                                                 PhysicalType data_type) {
 	for (idx_t index = 0; internal_compression_methods[index].get_function; index++) {
 		const auto &method = internal_compression_methods[index];
 		if (method.type == type) {
@@ -59,17 +59,17 @@ static CompressionFunction *LoadCompressionFunction(CompressionFunctionSet &set,
 	throw InternalException("Unsupported compression function type");
 }
 
-static void TryLoadCompression(DBConfig &config, vector<CompressionFunction *> &result, CompressionType type,
+static void TryLoadCompression(DBConfig &config, vector<reference<CompressionFunction>> &result, CompressionType type,
                                PhysicalType data_type) {
 	auto function = config.GetCompressionFunction(type, data_type);
 	if (!function) {
 		return;
 	}
-	result.push_back(function);
+	result.push_back(*function);
 }
 
-vector<CompressionFunction *> DBConfig::GetCompressionFunctions(PhysicalType data_type) {
-	vector<CompressionFunction *> result;
+vector<reference<CompressionFunction>> DBConfig::GetCompressionFunctions(PhysicalType data_type) {
+	vector<reference<CompressionFunction>> result;
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_UNCOMPRESSED, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_RLE, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_BITPACKING, data_type);
@@ -80,7 +80,7 @@ vector<CompressionFunction *> DBConfig::GetCompressionFunctions(PhysicalType dat
 	return result;
 }
 
-CompressionFunction *DBConfig::GetCompressionFunction(CompressionType type, PhysicalType data_type) {
+optional_ptr<CompressionFunction> DBConfig::GetCompressionFunction(CompressionType type, PhysicalType data_type) {
 	lock_guard<mutex> l(compression_functions->lock);
 	// check if the function is already loaded
 	auto function = FindCompressionFunction(*compression_functions, type, data_type);

package/src/duckdb/src/function/scalar/date/strftime.cpp

@@ -670,7 +670,7 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 }
 
 void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
-	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP);
+	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP || input.GetType().id() == LogicalTypeId::TIMESTAMP_TZ);
 	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
 	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
 	    input, result, count, [&](timestamp_t input, ValidityMask &mask, idx_t idx) {

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

@@ -325,6 +325,11 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 			// use the timestamp format to cast the chunk
 			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].ConvertTimestampVector(
 			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
+		} else if (options.has_format[LogicalTypeId::TIMESTAMP_TZ] &&
+		           csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP_TZ) {
+			// use the timestamp format to cast the chunk
+			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP_TZ].ConvertTimestampVector(
+			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
 		} else {
 			// non varchar column, perform the cast
 			VectorOperations::Cast(context.client, input.data[col_idx], cast_chunk.data[col_idx], input.size());

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

@@ -109,7 +109,7 @@ static void ExtractFunctions(ColumnDataCollection &collection, ExpressionInfo &i
 static void PragmaDetailedProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p,
                                                   DataChunk &output) {
 	auto &state = data_p.global_state->Cast<PragmaDetailedProfilingOutputOperatorData>();
-	auto &data = (PragmaDetailedProfilingOutputData &)*data_p.bind_data;
+	auto &data = data_p.bind_data->CastNoConst<PragmaDetailedProfilingOutputData>();
 
 	if (!state.initialized) {
 		// create a ColumnDataCollection
@@ -123,14 +123,15 @@ static void PragmaDetailedProfilingOutputFunction(ClientContext &context, TableF
 		int operator_counter = 1;
 		int function_counter = 1;
 		int expression_counter = 1;
-		if (ClientData::Get(context).query_profiler_history->GetPrevProfilers().empty()) {
+		auto &client_data = ClientData::Get(context);
+		if (client_data.query_profiler_history->GetPrevProfilers().empty()) {
 			return;
 		}
 		// For each Operator
-		for (auto op :
-		     ClientData::Get(context).query_profiler_history->GetPrevProfilers().back().second->GetTreeMap()) {
+		auto &tree_map = client_data.query_profiler_history->GetPrevProfilers().back().second->GetTreeMap();
+		for (auto op : tree_map) {
 			// For each Expression Executor
-			for (auto &expr_executor : op.second->info.executors_info) {
+			for (auto &expr_executor : op.second.get().info.executors_info) {
 				// For each Expression tree
 				if (!expr_executor) {
 					continue;

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

@@ -70,11 +70,13 @@ static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunct
 		DataChunk chunk;
 		chunk.Initialize(context, data.types);
 		int operator_counter = 1;
-		if (!ClientData::Get(context).query_profiler_history->GetPrevProfilers().empty()) {
-			for (auto op :
-			     ClientData::Get(context).query_profiler_history->GetPrevProfilers().back().second->GetTreeMap()) {
-				SetValue(chunk, chunk.size(), operator_counter++, op.second->name, op.second->info.time,
-				         op.second->info.elements, " ");
+		auto &client_data = ClientData::Get(context);
+		if (!client_data.query_profiler_history->GetPrevProfilers().empty()) {
+			auto &tree_map = client_data.query_profiler_history->GetPrevProfilers().back().second->GetTreeMap();
+			for (auto op : tree_map) {
+				auto &tree_info = op.second.get();
+				SetValue(chunk, chunk.size(), operator_counter++, tree_info.name, tree_info.info.time,
+				         tree_info.info.elements, " ");
 				chunk.SetCardinality(chunk.size() + 1);
 				if (chunk.size() == STANDARD_VECTOR_SIZE) {
 					collection->Append(chunk);