duckdb 0.7.2-dev1803.0 → 0.7.2-dev1898.0

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

@@ -19,10 +19,10 @@ PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types, TableCatalog
       bound_defaults(std::move(bound_defaults)) {
 }
 
-PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry *schema,
+PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema,
                                          unique_ptr<BoundCreateTableInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::BATCH_CREATE_TABLE_AS, op.types, estimated_cardinality),
-      insert_table(nullptr), schema(schema), info(std::move(info_p)) {
+      insert_table(nullptr), schema(&schema), info(std::move(info_p)) {
 	PhysicalInsert::GetInsertInfo(*info, insert_types, bound_defaults);
 }
 
@@ -100,7 +100,7 @@ public:
 	}
 
 	mutex lock;
-	DuckTableEntry *table;
+	optional_ptr<DuckTableEntry> table;
 	idx_t insert_count;
 	map<idx_t, unique_ptr<RowGroupCollection>> collections;
 
@@ -156,7 +156,8 @@ public:
 	}
 
 	void AddCollection(ClientContext &context, idx_t batch_index, unique_ptr<RowGroupCollection> current_collection,
-	                   OptimisticDataWriter *writer = nullptr, bool *written_to_disk = nullptr) {
+	                   optional_ptr<OptimisticDataWriter> writer = nullptr,
+	                   optional_ptr<bool> written_to_disk = nullptr) {
 		vector<unique_ptr<RowGroupCollection>> merge_collections;
 		idx_t merge_count;
 		{
@@ -240,7 +241,7 @@ public:
 	idx_t current_index;
 	TableAppendState current_append_state;
 	unique_ptr<RowGroupCollection> current_collection;
-	OptimisticDataWriter *writer;
+	optional_ptr<OptimisticDataWriter> writer;
 	bool written_to_disk;
 
 	void FlushToDisk() {
@@ -253,9 +254,9 @@ public:
 		writer->FlushToDisk(*current_collection, true);
 	}
 
-	void CreateNewCollection(DuckTableEntry *table, const vector<LogicalType> &insert_types) {
-		auto &table_info = table->GetStorage().info;
-		auto &block_manager = TableIOManager::Get(table->GetStorage()).GetBlockManagerForRowData();
+	void CreateNewCollection(DuckTableEntry &table, const vector<LogicalType> &insert_types) {
+		auto &table_info = table.GetStorage().info;
+		auto &block_manager = TableIOManager::Get(table.GetStorage()).GetBlockManagerForRowData();
 		current_collection = make_uniq<RowGroupCollection>(table_info, block_manager, insert_types, MAX_ROW_ID);
 		current_collection->InitializeEmpty();
 		current_collection->InitializeAppend(current_append_state);
@@ -269,8 +270,8 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table =
-		    (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
+		result->table = (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context),
+		                                                      *schema.get_mutable(), info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -289,12 +290,12 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 
 	auto table = gstate.table;
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	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.CreateNewCollection(*table, insert_types);
 		lstate.writer = gstate.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
@@ -303,7 +304,7 @@ 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;
 

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

@@ -53,10 +53,10 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
 	}
 }
 
-PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info_p,
+PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info_p,
                                idx_t estimated_cardinality, bool parallel)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE_AS, op.types, estimated_cardinality), insert_table(nullptr),
-      return_chunk(false), schema(schema), info(std::move(info_p)), parallel(parallel),
+      return_chunk(false), schema(&schema), info(std::move(info_p)), parallel(parallel),
       action_type(OnConflictAction::THROW) {
 	GetInsertInfo(*info, insert_types, bound_defaults);
 }
@@ -80,7 +80,7 @@ public:
 	}
 
 	mutex lock;
-	DuckTableEntry *table;
+	optional_ptr<DuckTableEntry> table;
 	idx_t insert_count;
 	bool initialized;
 	LocalAppendState append_state;
@@ -99,7 +99,7 @@ public:
 	ExpressionExecutor default_executor;
 	TableAppendState local_append_state;
 	unique_ptr<RowGroupCollection> local_collection;
-	OptimisticDataWriter *writer;
+	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
 	unordered_set<row_t> updated_rows;
 };
@@ -110,8 +110,8 @@ unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &co
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table =
-		    (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
+		result->table = (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context),
+		                                                      *schema.get_mutable(), info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -124,7 +124,7 @@ unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &c
 	return make_uniq<InsertLocalState>(context.client, insert_types, bound_defaults);
 }
 
-void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
+void PhysicalInsert::ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
                                      const physical_index_vector_t<idx_t> &column_index_map,
                                      ExpressionExecutor &default_executor, DataChunk &result) {
 	chunk.Flatten();
@@ -135,7 +135,7 @@ void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
 
 	if (!column_index_map.empty()) {
 		// columns specified by the user, use column_index_map
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto storage_idx = col.StorageOid();
 			auto mapped_index = column_index_map[col.Physical()];
 			if (mapped_index == DConstants::INVALID_INDEX) {
@@ -216,7 +216,7 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry *table,
+void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
                                              Vector &row_ids) const {
 	if (action_type == OnConflictAction::NOTHING) {
 		return;
@@ -255,9 +255,9 @@ void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChun
 	executor.Execute(chunk, update_chunk);
 	update_chunk.SetCardinality(chunk);
 
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
-	data_table.Update(*table, context.client, row_ids, set_columns, update_chunk);
+	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
 }
 
 // TODO: should we use a hash table to keep track of this instead?
@@ -274,11 +274,11 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionContext &context,
+void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
                                         InsertLocalState &lstate) const {
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	if (action_type == OnConflictAction::THROW) {
-		data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, nullptr);
+		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
 		return;
 	}
 	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
@@ -287,7 +287,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 	// We either want to do nothing, or perform an update when conflicts arise
 	ConflictInfo conflict_info(conflict_target);
 	ConflictManager conflict_manager(VerifyExistenceType::APPEND, lstate.insert_chunk.size(), &conflict_info);
-	data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, &conflict_manager);
+	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
 		// No conflicts found
@@ -312,7 +312,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
 		auto fetch_state = make_uniq<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, *table->catalog);
+		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
 		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
 	}
 
@@ -335,7 +335,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 			}
 			combined_chunk.Slice(sel.Selection(), sel.Count());
 			row_ids.Slice(sel.Selection(), sel.Count());
-			data_table.VerifyAppendConstraints(*table, context.client, combined_chunk, nullptr);
+			data_table.VerifyAppendConstraints(table, context.client, combined_chunk, nullptr);
 			throw InternalException("The previous operation was expected to throw but didn't");
 		}
 	}
@@ -359,7 +359,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 
 	auto table = gstate.table;
 	auto &storage = table->GetStorage();
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	PhysicalInsert::ResolveDefaults(*table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!parallel) {
 		if (!gstate.initialized) {
@@ -367,7 +367,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			gstate.initialized = true;
 		}
 
-		OnConflictHandling(table, context, lstate);
+		OnConflictHandling(*table, context, lstate);
 		storage.LocalAppend(gstate.append_state, *table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
@@ -387,7 +387,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
 			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);

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -7,7 +7,7 @@
 
 namespace duckdb {
 
-PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema,
+PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema,
                                          unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE, op.types, estimated_cardinality), schema(schema),
       info(std::move(info)) {
@@ -34,7 +34,7 @@ void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, G
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = *schema->catalog;
+	auto &catalog = *schema.catalog;
 	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, info.get());
 	state.finished = true;
 }

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

@@ -43,7 +43,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	    make_uniq<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
 	                                 op.info->names, std::move(table_filters), op.estimated_cardinality);
 
-	dependencies.AddDependency(&op.table);
+	dependencies.AddDependency(op.table);
 	op.info->column_ids.pop_back();
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());

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);
 	}
 
@@ -42,7 +42,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTabl
 		auto plan = CreatePlan(*op.children[0]);
 		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

@@ -25,7 +25,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(op.table);
+	dependencies.AddDependency(*op.table);
 	return op.table->catalog->PlanDelete(context, op, std::move(plan));
 }
 

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

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

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

@@ -22,7 +22,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(op.table);
+	dependencies.AddDependency(*op.table);
 	return op.table->catalog->PlanUpdate(context, op, std::move(plan));
 }