duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -13,9 +13,9 @@ namespace duckdb {
 
 WriteAheadLog::WriteAheadLog(AttachedDatabase &database, const string &path) : skip_writing(false), database(database) {
 	wal_path = path;
-	writer = make_unique<BufferedFileWriter>(FileSystem::Get(database), path.c_str(),
-	                                         FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE |
-	                                             FileFlags::FILE_FLAGS_APPEND);
+	writer = make_uniq<BufferedFileWriter>(FileSystem::Get(database), path.c_str(),
+	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE |
+	                                           FileFlags::FILE_FLAGS_APPEND);
 }
 
 WriteAheadLog::~WriteAheadLog() {
@@ -56,64 +56,64 @@ void WriteAheadLog::WriteCheckpoint(block_id_t meta_block) {
 //===--------------------------------------------------------------------===//
 // CREATE TABLE
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateTable(TableCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TABLE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
 //===--------------------------------------------------------------------===//
 // DROP TABLE
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropTable(TableCatalogEntry *entry) {
+void WriteAheadLog::WriteDropTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TABLE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // CREATE SCHEMA
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSchema(SchemaCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_SCHEMA);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // SEQUENCES
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSequence(SequenceCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_SEQUENCE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropSequence(SequenceCatalogEntry *entry) {
+void WriteAheadLog::WriteDropSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_SEQUENCE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
-void WriteAheadLog::WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValue val) {
+void WriteAheadLog::WriteSequenceValue(const SequenceCatalogEntry &entry, SequenceValue val) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::SEQUENCE_VALUE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 	writer->Write<uint64_t>(val.usage_count);
 	writer->Write<int64_t>(val.counter);
 }
@@ -121,109 +121,109 @@ void WriteAheadLog::WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValu
 //===--------------------------------------------------------------------===//
 // MACROS
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateMacro(ScalarMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_MACRO);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropMacro(ScalarMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteDropMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_MACRO);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
-void WriteAheadLog::WriteCreateTableMacro(TableMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TABLE_MACRO);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropTableMacro(TableMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TABLE_MACRO);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // Indexes
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateIndex(IndexCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_INDEX);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropIndex(IndexCatalogEntry *entry) {
+void WriteAheadLog::WriteDropIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_INDEX);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // Custom Types
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateType(TypeCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TYPE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropType(TypeCatalogEntry *entry) {
+void WriteAheadLog::WriteDropType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TYPE);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // VIEWS
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateView(ViewCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_VIEW);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropView(ViewCatalogEntry *entry) {
+void WriteAheadLog::WriteDropView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_VIEW);
-	writer->WriteString(entry->schema->name);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // DROP SCHEMA
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropSchema(SchemaCatalogEntry *entry) {
+void WriteAheadLog::WriteDropSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_SCHEMA);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
@@ -281,12 +281,12 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 //===--------------------------------------------------------------------===//
 // Write ALTER Statement
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(AlterInfo &info) {
+void WriteAheadLog::WriteAlter(data_ptr_t ptr, idx_t data_size) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::ALTER_INFO);
-	info.Serialize(*writer);
+	writer->WriteData(ptr, data_size);
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -29,12 +29,12 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::DELETE_TUPLE: {
 		auto info = (DeleteInfo *)data;
-		CleanupDelete(info);
+		CleanupDelete(*info);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		auto info = (UpdateInfo *)data;
-		CleanupUpdate(info);
+		CleanupUpdate(*info);
 		break;
 	}
 	default:
@@ -42,16 +42,16 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 	}
 }
 
-void CleanupState::CleanupUpdate(UpdateInfo *info) {
+void CleanupState::CleanupUpdate(UpdateInfo &info) {
 	// remove the update info from the update chain
 	// first obtain an exclusive lock on the segment
-	info->segment->CleanupUpdate(info);
+	info.segment->CleanupUpdate(info);
 }
 
-void CleanupState::CleanupDelete(DeleteInfo *info) {
-	auto version_table = info->table;
-	D_ASSERT(version_table->info->cardinality >= info->count);
-	version_table->info->cardinality -= info->count;
+void CleanupState::CleanupDelete(DeleteInfo &info) {
+	auto version_table = info.table;
+	D_ASSERT(version_table->info->cardinality >= info.count);
+	version_table->info->cardinality -= info.count;
 	if (version_table->info->indexes.Empty()) {
 		// this table has no indexes: no cleanup to be done
 		return;
@@ -62,8 +62,8 @@ void CleanupState::CleanupDelete(DeleteInfo *info) {
 		current_table = version_table;
 	}
 	count = 0;
-	for (idx_t i = 0; i < info->count; i++) {
-		row_numbers[count++] = info->vinfo->start + info->rows[i];
+	for (idx_t i = 0; i < info.count; i++) {
+		row_numbers[count++] = info.vinfo->start + info.rows[i];
 	}
 	Flush();
 }

package/src/duckdb/src/transaction/commit_state.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/column_data.hpp"
@@ -16,10 +15,11 @@
 #include "duckdb/transaction/delete_info.hpp"
 #include "duckdb/transaction/update_info.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 
 namespace duckdb {
 
-CommitState::CommitState(ClientContext &context, transaction_t commit_id, WriteAheadLog *log)
+CommitState::CommitState(ClientContext &context, transaction_t commit_id, optional_ptr<WriteAheadLog> log)
     : log(log), commit_id(commit_id), current_table_info(nullptr), context(context) {
 }
 
@@ -31,97 +31,101 @@ void CommitState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
 	}
 }
 
-void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
-	if (entry->temporary || entry->parent->temporary) {
+void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
+	if (entry.temporary || entry.parent->temporary) {
 		return;
 	}
 	D_ASSERT(log);
 	// look at the type of the parent entry
-	auto parent = entry->parent;
+	auto parent = entry.parent;
 	switch (parent->type) {
 	case CatalogType::TABLE_ENTRY:
-		if (entry->type == CatalogType::TABLE_ENTRY) {
-			auto table_entry = (DuckTableEntry *)entry;
-			D_ASSERT(table_entry->IsDuckTable());
+		if (entry.type == CatalogType::TABLE_ENTRY) {
+			auto &table_entry = entry.Cast<DuckTableEntry>();
+			D_ASSERT(table_entry.IsDuckTable());
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
-			// deserialize it
+
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
-			// write the alter table in the log
-			table_entry->CommitAlter(*info);
-			log->WriteAlter(*info);
+			string column_name = source.Read<string>();
+
+			if (!column_name.empty()) {
+				// write the alter table in the log
+				table_entry.CommitAlter(column_name);
+			}
+
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			// CREATE TABLE statement
-			log->WriteCreateTable((TableCatalogEntry *)parent);
+			log->WriteCreateTable(parent->Cast<TableCatalogEntry>());
 		}
 		break;
 	case CatalogType::SCHEMA_ENTRY:
-		if (entry->type == CatalogType::SCHEMA_ENTRY) {
+		if (entry.type == CatalogType::SCHEMA_ENTRY) {
 			// ALTER TABLE statement, skip it
 			return;
 		}
-		log->WriteCreateSchema((SchemaCatalogEntry *)parent);
+		log->WriteCreateSchema(parent->Cast<SchemaCatalogEntry>());
 		break;
 	case CatalogType::VIEW_ENTRY:
-		if (entry->type == CatalogType::VIEW_ENTRY) {
+		if (entry.type == CatalogType::VIEW_ENTRY) {
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
 			// deserialize it
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
+			string column_name = source.Read<string>();
 			// write the alter table in the log
-			log->WriteAlter(*info);
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
-			log->WriteCreateView((ViewCatalogEntry *)parent);
+			log->WriteCreateView(parent->Cast<ViewCatalogEntry>());
 		}
 		break;
 	case CatalogType::SEQUENCE_ENTRY:
-		log->WriteCreateSequence((SequenceCatalogEntry *)parent);
+		log->WriteCreateSequence(parent->Cast<SequenceCatalogEntry>());
 		break;
 	case CatalogType::MACRO_ENTRY:
-		log->WriteCreateMacro((ScalarMacroCatalogEntry *)parent);
+		log->WriteCreateMacro(parent->Cast<ScalarMacroCatalogEntry>());
 		break;
 	case CatalogType::TABLE_MACRO_ENTRY:
-		log->WriteCreateTableMacro((TableMacroCatalogEntry *)parent);
+		log->WriteCreateTableMacro(parent->Cast<TableMacroCatalogEntry>());
 		break;
 	case CatalogType::INDEX_ENTRY:
-		log->WriteCreateIndex((IndexCatalogEntry *)parent);
+		log->WriteCreateIndex(parent->Cast<IndexCatalogEntry>());
 		break;
 	case CatalogType::TYPE_ENTRY:
-		log->WriteCreateType((TypeCatalogEntry *)parent);
+		log->WriteCreateType(parent->Cast<TypeCatalogEntry>());
 		break;
 	case CatalogType::DELETED_ENTRY:
-		switch (entry->type) {
+		switch (entry.type) {
 		case CatalogType::TABLE_ENTRY: {
-			auto table_entry = (DuckTableEntry *)entry;
-			D_ASSERT(table_entry->IsDuckTable());
-			table_entry->CommitDrop();
+			auto &table_entry = entry.Cast<DuckTableEntry>();
+			D_ASSERT(table_entry.IsDuckTable());
+			table_entry.CommitDrop();
 			log->WriteDropTable(table_entry);
 			break;
 		}
 		case CatalogType::SCHEMA_ENTRY:
-			log->WriteDropSchema((SchemaCatalogEntry *)entry);
+			log->WriteDropSchema(entry.Cast<SchemaCatalogEntry>());
 			break;
 		case CatalogType::VIEW_ENTRY:
-			log->WriteDropView((ViewCatalogEntry *)entry);
+			log->WriteDropView(entry.Cast<ViewCatalogEntry>());
 			break;
 		case CatalogType::SEQUENCE_ENTRY:
-			log->WriteDropSequence((SequenceCatalogEntry *)entry);
+			log->WriteDropSequence(entry.Cast<SequenceCatalogEntry>());
 			break;
 		case CatalogType::MACRO_ENTRY:
-			log->WriteDropMacro((ScalarMacroCatalogEntry *)entry);
+			log->WriteDropMacro(entry.Cast<ScalarMacroCatalogEntry>());
 			break;
 		case CatalogType::TABLE_MACRO_ENTRY:
-			log->WriteDropTableMacro((TableMacroCatalogEntry *)entry);
+			log->WriteDropTableMacro(entry.Cast<TableMacroCatalogEntry>());
 			break;
 		case CatalogType::TYPE_ENTRY:
-			log->WriteDropType((TypeCatalogEntry *)entry);
+			log->WriteDropType(entry.Cast<TypeCatalogEntry>());
 			break;
 		case CatalogType::INDEX_ENTRY:
-			log->WriteDropIndex((IndexCatalogEntry *)entry);
+			log->WriteDropIndex(entry.Cast<IndexCatalogEntry>());
 			break;
 		case CatalogType::PREPARED_STATEMENT:
 		case CatalogType::SCALAR_FUNCTION_ENTRY:
@@ -145,28 +149,28 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 	}
 }
 
-void CommitState::WriteDelete(DeleteInfo *info) {
+void CommitState::WriteDelete(DeleteInfo &info) {
 	D_ASSERT(log);
 	// switch to the current table, if necessary
-	SwitchTable(info->table->info.get(), UndoFlags::DELETE_TUPLE);
+	SwitchTable(info.table->info.get(), UndoFlags::DELETE_TUPLE);
 
 	if (!delete_chunk) {
-		delete_chunk = make_unique<DataChunk>();
+		delete_chunk = make_uniq<DataChunk>();
 		vector<LogicalType> delete_types = {LogicalType::ROW_TYPE};
 		delete_chunk->Initialize(Allocator::DefaultAllocator(), delete_types);
 	}
 	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
-	for (idx_t i = 0; i < info->count; i++) {
-		rows[i] = info->base_row + info->rows[i];
+	for (idx_t i = 0; i < info.count; i++) {
+		rows[i] = info.base_row + info.rows[i];
 	}
-	delete_chunk->SetCardinality(info->count);
+	delete_chunk->SetCardinality(info.count);
 	log->WriteDelete(*delete_chunk);
 }
 
-void CommitState::WriteUpdate(UpdateInfo *info) {
+void CommitState::WriteUpdate(UpdateInfo &info) {
 	D_ASSERT(log);
 	// switch to the current table, if necessary
-	auto &column_data = info->segment->column_data;
+	auto &column_data = info.segment->column_data;
 	auto &table_info = column_data.GetTableInfo();
 
 	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
@@ -180,29 +184,29 @@ void CommitState::WriteUpdate(UpdateInfo *info) {
 	}
 	update_types.emplace_back(LogicalType::ROW_TYPE);
 
-	update_chunk = make_unique<DataChunk>();
+	update_chunk = make_uniq<DataChunk>();
 	update_chunk->Initialize(Allocator::DefaultAllocator(), update_types);
 
 	// fetch the updated values from the base segment
-	info->segment->FetchCommitted(info->vector_index, update_chunk->data[0]);
+	info.segment->FetchCommitted(info.vector_index, update_chunk->data[0]);
 
 	// write the row ids into the chunk
 	auto row_ids = FlatVector::GetData<row_t>(update_chunk->data[1]);
-	idx_t start = column_data.start + info->vector_index * STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < info->N; i++) {
-		row_ids[info->tuples[i]] = start + info->tuples[i];
+	idx_t start = column_data.start + info.vector_index * STANDARD_VECTOR_SIZE;
+	for (idx_t i = 0; i < info.N; i++) {
+		row_ids[info.tuples[i]] = start + info.tuples[i];
 	}
 	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
 		// zero-initialize the booleans
 		// FIXME: this is only required because of NullValue<T> in Vector::Serialize...
 		auto booleans = FlatVector::GetData<bool>(update_chunk->data[0]);
-		for (idx_t i = 0; i < info->N; i++) {
-			auto idx = info->tuples[i];
+		for (idx_t i = 0; i < info.N; i++) {
+			auto idx = info.tuples[i];
 			booleans[idx] = false;
 		}
 	}
-	SelectionVector sel(info->tuples);
-	update_chunk->Slice(sel, info->N);
+	SelectionVector sel(info.tuples);
+	update_chunk->Slice(sel, info.N);
 
 	// construct the column index path
 	vector<column_t> column_indexes;
@@ -211,7 +215,7 @@ void CommitState::WriteUpdate(UpdateInfo *info) {
 		column_indexes.push_back(column_data_ptr->column_index);
 		column_data_ptr = column_data_ptr->parent;
 	}
-	column_indexes.push_back(info->column_index);
+	column_indexes.push_back(info.column_index);
 	std::reverse(column_indexes.begin(), column_indexes.end());
 
 	log->WriteUpdate(*update_chunk, column_indexes);
@@ -230,15 +234,15 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		D_ASSERT(catalog->IsDuckCatalog());
 
 		// Grab a write lock on the catalog
-		auto &duck_catalog = (DuckCatalog &)*catalog;
+		auto &duck_catalog = catalog->Cast<DuckCatalog>();
 		lock_guard<mutex> write_lock(duck_catalog.GetWriteLock());
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, commit_id);
+		catalog_entry->set->UpdateTimestamp(*catalog_entry->parent, commit_id);
 		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, commit_id);
+			catalog_entry->set->UpdateTimestamp(*catalog_entry, commit_id);
 		}
 		if (HAS_LOG) {
 			// push the catalog update to the WAL
-			WriteCatalogEntry(catalog_entry, data + sizeof(CatalogEntry *));
+			WriteCatalogEntry(*catalog_entry, data + sizeof(CatalogEntry *));
 		}
 		break;
 	}
@@ -256,7 +260,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		// deletion:
 		auto info = (DeleteInfo *)data;
 		if (HAS_LOG && !info->table->info->IsTemporary()) {
-			WriteDelete(info);
+			WriteDelete(*info);
 		}
 		// mark the tuples as committed
 		info->vinfo->CommitDelete(commit_id, info->rows, info->count);
@@ -266,7 +270,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		// update:
 		auto info = (UpdateInfo *)data;
 		if (HAS_LOG && !info->segment->column_data.GetTableInfo().IsTemporary()) {
-			WriteUpdate(info);
+			WriteUpdate(*info);
 		}
 		info->version_number = commit_id;
 		break;
@@ -283,9 +287,9 @@ void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
 		// set the commit timestamp of the catalog entry to the given id
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry->parent);
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, transaction_id);
+		catalog_entry->set->UpdateTimestamp(*catalog_entry->parent, transaction_id);
 		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, transaction_id);
+			catalog_entry->set->UpdateTimestamp(*catalog_entry, transaction_id);
 		}
 		break;
 	}

package/src/duckdb/src/transaction/duck_transaction.cpp

@@ -29,7 +29,7 @@ TransactionData::TransactionData(transaction_t transaction_id_p, transaction_t s
 DuckTransaction::DuckTransaction(TransactionManager &manager, ClientContext &context_p, transaction_t start_time,
                                  transaction_t transaction_id)
     : Transaction(manager, context_p), start_time(start_time), transaction_id(transaction_id), commit_id(0),
-      highest_active_query(0), undo_buffer(context_p), storage(make_unique<LocalStorage>(context_p, *this)) {
+      highest_active_query(0), undo_buffer(context_p), storage(make_uniq<LocalStorage>(context_p, *this)) {
 }
 
 DuckTransaction::~DuckTransaction() {
@@ -51,14 +51,14 @@ LocalStorage &DuckTransaction::GetLocalStorage() {
 	return *storage;
 }
 
-void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data, idx_t extra_data_size) {
+void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size) {
 	idx_t alloc_size = sizeof(CatalogEntry *);
 	if (extra_data_size > 0) {
 		alloc_size += extra_data_size + sizeof(idx_t);
 	}
 	auto baseptr = undo_buffer.CreateEntry(UndoFlags::CATALOG_ENTRY, alloc_size);
 	// store the pointer to the catalog entry
-	Store<CatalogEntry *>(entry, baseptr);
+	Store<CatalogEntry *>(&entry, baseptr);
 	if (extra_data_size > 0) {
 		// copy the extra data behind the catalog entry pointer (if any)
 		baseptr += sizeof(CatalogEntry *);
@@ -70,19 +70,19 @@ void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_dat
 	}
 }
 
-void DuckTransaction::PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
+void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
 	auto delete_info =
 	    (DeleteInfo *)undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count);
 	delete_info->vinfo = vinfo;
-	delete_info->table = table;
+	delete_info->table = &table;
 	delete_info->count = count;
 	delete_info->base_row = base_row;
 	memcpy(delete_info->rows, rows, sizeof(row_t) * count);
 }
 
-void DuckTransaction::PushAppend(DataTable *table, idx_t start_row, idx_t row_count) {
+void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_count) {
 	auto append_info = (AppendInfo *)undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
-	append_info->table = table;
+	append_info->table = &table;
 	append_info->start_row = start_row;
 	append_info->count = row_count;
 }
@@ -116,7 +116,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 	UndoBuffer::IteratorState iterator_state;
 	LocalStorage::CommitState commit_state;
 	unique_ptr<StorageCommitState> storage_commit_state;
-	WriteAheadLog *log;
+	optional_ptr<WriteAheadLog> log;
 	if (!db.IsSystem()) {
 		auto &storage_manager = db.GetStorageManager();
 		log = storage_manager.GetWriteAheadLog();
@@ -130,7 +130,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 		if (log) {
 			// commit any sequences that were used to the WAL
 			for (auto &entry : sequence_usage) {
-				log->WriteSequenceValue(entry.first, entry.second);
+				log->WriteSequenceValue(*entry.first, entry.second);
 			}
 		}
 		if (storage_commit_state) {