duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/src/storage/index.cpp

@@ -1,122 +1,18 @@
 #include "duckdb/storage/index.hpp"
-
 #include "duckdb/common/radix.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/storage/table/append_state.hpp"
 
 namespace duckdb {
 
-Index::Index(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
-             const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-             const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db)
+Index::Index(const vector<column_t> &column_ids, TableIOManager &table_io_manager, AttachedDatabase &db)
 
-    : name(name), index_type(index_type), index_constraint_type(index_constraint_type), column_ids(column_ids),
-      table_io_manager(table_io_manager), db(db) {
+    : column_ids(column_ids), table_io_manager(table_io_manager), db(db) {
 
 	if (!Radix::IsLittleEndian()) {
 		throw NotImplementedException("indexes are not supported on big endian architectures");
 	}
-
-	for (auto &expr : unbound_expressions) {
-		types.push_back(expr->return_type.InternalType());
-		logical_types.push_back(expr->return_type);
-		auto unbound_expression = expr->Copy();
-		bound_expressions.push_back(BindExpression(unbound_expression->Copy()));
-		this->unbound_expressions.emplace_back(std::move(unbound_expression));
-	}
-	for (auto &bound_expr : bound_expressions) {
-		executor.AddExpression(*bound_expr);
-	}
-
 	// create the column id set
 	column_id_set.insert(column_ids.begin(), column_ids.end());
 }
 
-void Index::InitializeLock(IndexLock &state) {
-	state.index_lock = unique_lock<mutex>(lock);
-}
-
-ErrorData Index::Append(DataChunk &entries, Vector &row_identifiers) {
-	IndexLock state;
-	InitializeLock(state);
-	return Append(state, entries, row_identifiers);
-}
-
-void Index::CommitDrop() {
-	IndexLock index_lock;
-	InitializeLock(index_lock);
-	CommitDrop(index_lock);
-}
-
-void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
-	IndexLock state;
-	InitializeLock(state);
-	Delete(state, entries, row_identifiers);
-}
-
-bool Index::MergeIndexes(Index &other_index) {
-	IndexLock state;
-	InitializeLock(state);
-	return MergeIndexes(state, other_index);
-}
-
-string Index::VerifyAndToString(const bool only_verify) {
-	IndexLock state;
-	InitializeLock(state);
-	return VerifyAndToString(state, only_verify);
-}
-
-void Index::Vacuum() {
-	IndexLock state;
-	InitializeLock(state);
-	Vacuum(state);
-}
-
-idx_t Index::GetInMemorySize() {
-	IndexLock state;
-	InitializeLock(state);
-	return GetInMemorySize(state);
-}
-
-void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {
-	executor.Execute(input, result);
-}
-
-unique_ptr<Expression> Index::BindExpression(unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-		return make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
-	}
-	ExpressionIterator::EnumerateChildren(
-	    *expr, [this](unique_ptr<Expression> &expr) { expr = BindExpression(std::move(expr)); });
-	return expr;
-}
-
-bool Index::IndexIsUpdated(const vector<PhysicalIndex> &column_ids_p) const {
-	for (auto &column : column_ids_p) {
-		if (column_id_set.find(column.index) != column_id_set.end()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-IndexStorageInfo Index::GetStorageInfo(const bool get_buffers) {
-	throw NotImplementedException("The implementation of this index serialization does not exist.");
-}
-
-string Index::AppendRowError(DataChunk &input, idx_t index) {
-	string error;
-	for (idx_t c = 0; c < input.ColumnCount(); c++) {
-		if (c > 0) {
-			error += ", ";
-		}
-		error += input.GetValue(c, index).ToString();
-	}
-	return error;
-}
-
 } // namespace duckdb

package/src/duckdb/src/storage/local_storage.cpp

@@ -14,30 +14,25 @@
 
 namespace duckdb {
 
-LocalTableStorage::LocalTableStorage(DataTable &table)
+LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &table)
     : table_ref(table), allocator(Allocator::Get(table.db)), deleted_rows(0), optimistic_writer(table),
       merged_storage(false) {
 	auto types = table.GetTypes();
-	row_groups = make_shared<RowGroupCollection>(table.info, TableIOManager::Get(table).GetBlockManagerForRowData(),
-	                                             types, MAX_ROW_ID, 0);
+	auto data_table_info = table.GetDataTableInfo();
+	row_groups = make_shared_ptr<RowGroupCollection>(
+	    data_table_info, TableIOManager::Get(table).GetBlockManagerForRowData(), types, MAX_ROW_ID, 0);
 	row_groups->InitializeEmpty();
 
-	table.info->indexes.Scan([&](Index &index) {
-		if (index.index_type != ART::TYPE_NAME) {
-			return false;
-		}
-		D_ASSERT(index.index_type == ART::TYPE_NAME);
-
-		auto &art = index.Cast<ART>();
-		if (art.index_constraint_type != IndexConstraintType::NONE) {
+	data_table_info->GetIndexes().BindAndScan<ART>(context, *data_table_info, [&](ART &art) {
+		if (art.GetConstraintType() != IndexConstraintType::NONE) {
 			// unique index: create a local ART index that maintains the same unique constraint
 			vector<unique_ptr<Expression>> unbound_expressions;
 			unbound_expressions.reserve(art.unbound_expressions.size());
 			for (auto &expr : art.unbound_expressions) {
 				unbound_expressions.push_back(expr->Copy());
 			}
-			indexes.AddIndex(make_uniq<ART>(art.name, art.index_constraint_type, art.column_ids, art.table_io_manager,
-			                                std::move(unbound_expressions), art.db));
+			indexes.AddIndex(make_uniq<ART>(art.GetIndexName(), art.GetConstraintType(), art.GetColumnIds(),
+			                                art.table_io_manager, std::move(unbound_expressions), art.db));
 		}
 		return false;
 	});
@@ -64,11 +59,11 @@ LocalTableStorage::LocalTableStorage(DataTable &new_dt, LocalTableStorage &paren
 }
 
 LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     ColumnDefinition &new_column, Expression &default_value)
+                                     ColumnDefinition &new_column, ExpressionExecutor &default_executor)
     : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
       optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
       merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->AddColumn(context, new_column, default_value);
+	row_groups = parent.row_groups->AddColumn(context, new_column, default_executor);
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
@@ -97,7 +92,8 @@ idx_t LocalTableStorage::EstimatedSize() {
 	// get the index size
 	idx_t index_sizes = 0;
 	indexes.Scan([&](Index &index) {
-		index_sizes += index.GetInMemorySize();
+		D_ASSERT(index.IsBound());
+		index_sizes += index.Cast<BoundIndex>().GetInMemorySize();
 		return false;
 	});
 
@@ -167,8 +163,9 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 			return true;
 		});
 	} else {
-		error =
-		    AppendToIndexes(transaction, *row_groups, table.info->indexes, table.GetTypes(), append_state.current_row);
+		auto data_table_info = table.GetDataTableInfo();
+		auto &index_list = data_table_info->GetIndexes();
+		error = AppendToIndexes(transaction, *row_groups, index_list, table.GetTypes(), append_state.current_row);
 	}
 	if (error.HasError()) {
 		// need to revert all appended row ids
@@ -191,19 +188,12 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 			return true;
 		});
 		if (append_to_table) {
-			table.RevertAppendInternal(append_state.row_start);
+			table.RevertAppendInternal(NumericCast<idx_t>(append_state.row_start));
 		}
 
 		// we need to vacuum the indexes to remove any buffers that are now empty
 		// due to reverting the appends
-		table.info->indexes.Scan([&](Index &index) {
-			try {
-				index.Vacuum();
-			} catch (std::exception &ex) { // LCOV_EXCL_START
-				error = ErrorData(ex);
-			} // LCOV_EXCL_STOP
-			return false;
-		});
+		table.VacuumIndexes();
 		error.Throw();
 	}
 	if (append_to_table) {
@@ -223,7 +213,7 @@ void LocalTableStorage::FinalizeOptimisticWriter(OptimisticDataWriter &writer) {
 	for (idx_t i = 0; i < optimistic_writers.size(); i++) {
 		if (optimistic_writers[i].get() == &writer) {
 			owned_writer = std::move(optimistic_writers[i]);
-			optimistic_writers.erase(optimistic_writers.begin() + i);
+			optimistic_writers.erase_at(i);
 			break;
 		}
 	}
@@ -250,11 +240,11 @@ optional_ptr<LocalTableStorage> LocalTableManager::GetStorage(DataTable &table)
 	return entry == table_storage.end() ? nullptr : entry->second.get();
 }
 
-LocalTableStorage &LocalTableManager::GetOrCreateStorage(DataTable &table) {
+LocalTableStorage &LocalTableManager::GetOrCreateStorage(ClientContext &context, DataTable &table) {
 	lock_guard<mutex> l(table_storage_lock);
 	auto entry = table_storage.find(table);
 	if (entry == table_storage.end()) {
-		auto new_storage = make_shared<LocalTableStorage>(table);
+		auto new_storage = make_shared_ptr<LocalTableStorage>(context, table);
 		auto storage = new_storage.get();
 		table_storage.insert(make_pair(reference<DataTable>(table), std::move(new_storage)));
 		return *storage;
@@ -358,16 +348,17 @@ bool LocalStorage::NextParallelScan(ClientContext &context, DataTable &table, Pa
 }
 
 void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable &table) {
-	table.info->InitializeIndexes(context);
-	state.storage = &table_manager.GetOrCreateStorage(table);
+	table.InitializeIndexes(context);
+	state.storage = &table_manager.GetOrCreateStorage(context, table);
 	state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state);
 }
 
 void LocalStorage::Append(LocalAppendState &state, DataChunk &chunk) {
 	// append to unique indices (if any)
 	auto storage = state.storage;
-	idx_t base_id = MAX_ROW_ID + storage->row_groups->GetTotalRows() + state.append_state.total_append_count;
-	auto error = DataTable::AppendToIndexes(storage->indexes, chunk, base_id);
+	idx_t base_id =
+	    NumericCast<idx_t>(MAX_ROW_ID) + storage->row_groups->GetTotalRows() + state.append_state.total_append_count;
+	auto error = DataTable::AppendToIndexes(storage->indexes, chunk, NumericCast<row_t>(base_id));
 	if (error.HasError()) {
 		error.Throw();
 	}
@@ -385,10 +376,10 @@ void LocalStorage::FinalizeAppend(LocalAppendState &state) {
 }
 
 void LocalStorage::LocalMerge(DataTable &table, RowGroupCollection &collection) {
-	auto &storage = table_manager.GetOrCreateStorage(table);
+	auto &storage = table_manager.GetOrCreateStorage(context, table);
 	if (!storage.indexes.Empty()) {
 		// append data to indexes if required
-		row_t base_id = MAX_ROW_ID + storage.row_groups->GetTotalRows();
+		row_t base_id = MAX_ROW_ID + NumericCast<row_t>(storage.row_groups->GetTotalRows());
 		auto error = storage.AppendToIndexes(transaction, collection, storage.indexes, table.GetTypes(), base_id);
 		if (error.HasError()) {
 			error.Throw();
@@ -399,12 +390,12 @@ void LocalStorage::LocalMerge(DataTable &table, RowGroupCollection &collection)
 }
 
 OptimisticDataWriter &LocalStorage::CreateOptimisticWriter(DataTable &table) {
-	auto &storage = table_manager.GetOrCreateStorage(table);
+	auto &storage = table_manager.GetOrCreateStorage(context, table);
 	return storage.CreateOptimisticWriter();
 }
 
 void LocalStorage::FinalizeOptimisticWriter(DataTable &table, OptimisticDataWriter &writer) {
-	auto &storage = table_manager.GetOrCreateStorage(table);
+	auto &storage = table_manager.GetOrCreateStorage(context, table);
 	storage.FinalizeOptimisticWriter(writer);
 }
 
@@ -450,11 +441,11 @@ void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
 	}
 	idx_t append_count = storage.row_groups->GetTotalRows() - storage.deleted_rows;
 
-	table.info->InitializeIndexes(context);
+	table.InitializeIndexes(context);
 
 	TableAppendState append_state;
 	table.AppendLock(append_state);
-	transaction.PushAppend(table, append_state.row_start, append_count);
+	transaction.PushAppend(table, NumericCast<idx_t>(append_state.row_start), append_count);
 	if ((append_state.row_start == 0 || storage.row_groups->GetTotalRows() >= MERGE_THRESHOLD) &&
 	    storage.deleted_rows == 0) {
 		// table is currently empty OR we are bulk appending: move over the storage directly
@@ -463,7 +454,7 @@ void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
 		// now append to the indexes (if there are any)
 		// FIXME: we should be able to merge the transaction-local index directly into the main table index
 		// as long we just rewrite some row-ids
-		if (!table.info->indexes.Empty()) {
+		if (table.HasIndexes()) {
 			storage.AppendToIndexes(transaction, append_state, append_count, false);
 		}
 		// finally move over the row groups
@@ -478,10 +469,7 @@ void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
 	}
 
 	// possibly vacuum any excess index data
-	table.info->indexes.Scan([&](Index &index) {
-		index.Vacuum();
-		return false;
-	});
+	table.VacuumIndexes();
 }
 
 void LocalStorage::Commit(LocalStorage::CommitState &commit_state, DuckTransaction &transaction) {
@@ -532,13 +520,13 @@ void LocalStorage::MoveStorage(DataTable &old_dt, DataTable &new_dt) {
 }
 
 void LocalStorage::AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-                             Expression &default_value) {
+                             ExpressionExecutor &default_executor) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
 	if (!storage) {
 		return;
 	}
-	auto new_storage = make_shared<LocalTableStorage>(context, new_dt, *storage, new_column, default_value);
+	auto new_storage = make_shared_ptr<LocalTableStorage>(context, new_dt, *storage, new_column, default_executor);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
@@ -548,7 +536,7 @@ void LocalStorage::DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t remove
 	if (!storage) {
 		return;
 	}
-	auto new_storage = make_shared<LocalTableStorage>(new_dt, *storage, removed_column);
+	auto new_storage = make_shared_ptr<LocalTableStorage>(new_dt, *storage, removed_column);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
@@ -559,8 +547,8 @@ void LocalStorage::ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t change
 	if (!storage) {
 		return;
 	}
-	auto new_storage =
-	    make_shared<LocalTableStorage>(context, new_dt, *storage, changed_idx, target_type, bound_columns, cast_expr);
+	auto new_storage = make_shared_ptr<LocalTableStorage>(context, new_dt, *storage, changed_idx, target_type,
+	                                                      bound_columns, cast_expr);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 

package/src/duckdb/src/storage/metadata/metadata_manager.cpp

@@ -33,7 +33,7 @@ MetadataHandle MetadataManager::AllocateHandle() {
 
 	// select the first free metadata block we can find
 	MetadataPointer pointer;
-	pointer.block_index = free_block;
+	pointer.block_index = UnsafeNumericCast<idx_t>(free_block);
 	auto &block = blocks[free_block];
 	if (block.block->BlockId() < MAXIMUM_BLOCK) {
 		// this block is a disk-backed block, yet we are planning to write to it
@@ -134,7 +134,7 @@ MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) {
 		                        pointer.block_pointer);
 	} // LCOV_EXCL_STOP
 	MetadataPointer result;
-	result.block_index = block_id;
+	result.block_index = UnsafeNumericCast<idx_t>(block_id);
 	result.index = UnsafeNumericCast<uint8_t>(index);
 	return result;
 }

package/src/duckdb/src/storage/metadata/metadata_writer.cpp

@@ -48,7 +48,7 @@ void MetadataWriter::NextBlock() {
 	current_pointer = block.pointer;
 	offset = sizeof(idx_t);
 	capacity = MetadataManager::METADATA_BLOCK_SIZE;
-	Store<idx_t>(-1, BasePtr());
+	Store<idx_t>(static_cast<idx_t>(-1), BasePtr());
 	if (written_pointers) {
 		written_pointers->push_back(manager.GetDiskPointer(current_pointer));
 	}

package/src/duckdb/src/storage/optimistic_data_writer.cpp

@@ -19,14 +19,14 @@ OptimisticDataWriter::~OptimisticDataWriter() {
 
 bool OptimisticDataWriter::PrepareWrite() {
 	// check if we should pre-emptively write the table to disk
-	if (table.info->IsTemporary() || StorageManager::Get(table.info->db).InMemory()) {
+	if (table.IsTemporary() || StorageManager::Get(table.GetAttached()).InMemory()) {
 		return false;
 	}
 	// we should! write the second-to-last row group to disk
 	// allocate the partial block-manager if none is allocated yet
 	if (!partial_manager) {
-		auto &block_manager = table.info->table_io_manager->GetBlockManagerForRowData();
-		partial_manager = make_uniq<PartialBlockManager>(block_manager, CheckpointType::APPEND_TO_TABLE);
+		auto &block_manager = table.GetTableIOManager().GetBlockManagerForRowData();
+		partial_manager = make_uniq<PartialBlockManager>(block_manager, PartialBlockType::APPEND_TO_TABLE);
 	}
 	return true;
 }
@@ -38,7 +38,7 @@ void OptimisticDataWriter::WriteNewRowGroup(RowGroupCollection &row_groups) {
 	}
 	// flush second-to-last row group
 	auto row_group = row_groups.GetRowGroup(-2);
-	FlushToDisk(row_group);
+	FlushToDisk(*row_group);
 }
 
 void OptimisticDataWriter::WriteLastRowGroup(RowGroupCollection &row_groups) {
@@ -51,20 +51,18 @@ void OptimisticDataWriter::WriteLastRowGroup(RowGroupCollection &row_groups) {
 	if (!row_group) {
 		return;
 	}
-	FlushToDisk(row_group);
+	FlushToDisk(*row_group);
 }
 
-void OptimisticDataWriter::FlushToDisk(RowGroup *row_group) {
-	if (!row_group) {
-		throw InternalException("FlushToDisk called without a RowGroup");
-	}
+void OptimisticDataWriter::FlushToDisk(RowGroup &row_group) {
 	//! The set of column compression types (if any)
 	vector<CompressionType> compression_types;
 	D_ASSERT(compression_types.empty());
-	for (auto &column : table.column_definitions) {
+	for (auto &column : table.Columns()) {
 		compression_types.push_back(column.CompressionType());
 	}
-	row_group->WriteToDisk(*partial_manager, compression_types);
+	RowGroupWriteInfo info(*partial_manager, compression_types);
+	row_group.WriteToDisk(info);
 }
 
 void OptimisticDataWriter::Merge(OptimisticDataWriter &other) {

package/src/duckdb/src/storage/partial_block_manager.cpp

@@ -34,10 +34,10 @@ void PartialBlock::FlushInternal(const idx_t free_space_left) {
 // PartialBlockManager
 //===--------------------------------------------------------------------===//
 
-PartialBlockManager::PartialBlockManager(BlockManager &block_manager, CheckpointType checkpoint_type,
+PartialBlockManager::PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
                                          uint32_t max_partial_block_size, uint32_t max_use_count)
-    : block_manager(block_manager), checkpoint_type(checkpoint_type), max_partial_block_size(max_partial_block_size),
-      max_use_count(max_use_count) {
+    : block_manager(block_manager), partial_block_type(partial_block_type),
+      max_partial_block_size(max_partial_block_size), max_use_count(max_use_count) {
 }
 PartialBlockManager::~PartialBlockManager() {
 }
@@ -54,7 +54,7 @@ PartialBlockAllocation PartialBlockManager::GetBlockAllocation(uint32_t segment_
 		//! there is! increase the reference count of this block
 		allocation.partial_block->state.block_use_count += 1;
 		allocation.state = allocation.partial_block->state;
-		if (checkpoint_type == CheckpointType::FULL_CHECKPOINT) {
+		if (partial_block_type == PartialBlockType::FULL_CHECKPOINT) {
 			block_manager.IncreaseBlockReferenceCount(allocation.state.block_id);
 		}
 	} else {
@@ -71,7 +71,7 @@ bool PartialBlockManager::HasBlockAllocation(uint32_t segment_size) {
 
 void PartialBlockManager::AllocateBlock(PartialBlockState &state, uint32_t segment_size) {
 	D_ASSERT(segment_size <= Storage::BLOCK_SIZE);
-	if (checkpoint_type == CheckpointType::FULL_CHECKPOINT) {
+	if (partial_block_type == PartialBlockType::FULL_CHECKPOINT) {
 		state.block_id = block_manager.GetFreeBlockId();
 	} else {
 		state.block_id = INVALID_BLOCK;
@@ -97,7 +97,7 @@ bool PartialBlockManager::GetPartialBlock(idx_t segment_size, unique_ptr<Partial
 
 void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation allocation) {
 	auto &state = allocation.partial_block->state;
-	D_ASSERT(checkpoint_type != CheckpointType::FULL_CHECKPOINT || state.block_id >= 0);
+	D_ASSERT(partial_block_type != PartialBlockType::FULL_CHECKPOINT || state.block_id >= 0);
 	if (state.block_use_count < max_use_count) {
 		auto unaligned_size = allocation.allocation_size + state.offset;
 		auto new_size = AlignValue(unaligned_size);

package/src/duckdb/src/storage/serialization/serialize_create_info.cpp

@@ -25,6 +25,10 @@ void CreateInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty<OnCreateConflict>(105, "on_conflict", on_conflict);
 	serializer.WritePropertyWithDefault<string>(106, "sql", sql);
 	serializer.WritePropertyWithDefault<Value>(107, "comment", comment, Value());
+	serializer.WritePropertyWithDefault<unordered_map<string, string>>(108, "tags", tags, unordered_map<string, string>());
+	if (serializer.ShouldSerialize(2)) {
+		serializer.WritePropertyWithDefault<LogicalDependencyList>(109, "dependencies", dependencies, LogicalDependencyList());
+	}
 }
 
 unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
@@ -36,6 +40,8 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>(105, "on_conflict");
 	auto sql = deserializer.ReadPropertyWithDefault<string>(106, "sql");
 	auto comment = deserializer.ReadPropertyWithDefault<Value>(107, "comment", Value());
+	auto tags = deserializer.ReadPropertyWithDefault<unordered_map<string, string>>(108, "tags", unordered_map<string, string>());
+	auto dependencies = deserializer.ReadPropertyWithDefault<LogicalDependencyList>(109, "dependencies", LogicalDependencyList());
 	deserializer.Set<CatalogType>(type);
 	unique_ptr<CreateInfo> result;
 	switch (type) {
@@ -74,6 +80,8 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 	result->on_conflict = on_conflict;
 	result->sql = std::move(sql);
 	result->comment = comment;
+	result->tags = std::move(tags);
+	result->dependencies = dependencies;
 	return result;
 }
 

package/src/duckdb/src/storage/serialization/serialize_dependency.cpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/catalog/dependency.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
+
+namespace duckdb {
+
+void CatalogEntryInfo::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<CatalogType>(100, "type", type);
+	serializer.WritePropertyWithDefault<string>(101, "schema", schema);
+	serializer.WritePropertyWithDefault<string>(102, "name", name);
+}
+
+CatalogEntryInfo CatalogEntryInfo::Deserialize(Deserializer &deserializer) {
+	CatalogEntryInfo result;
+	deserializer.ReadProperty<CatalogType>(100, "type", result.type);
+	deserializer.ReadPropertyWithDefault<string>(101, "schema", result.schema);
+	deserializer.ReadPropertyWithDefault<string>(102, "name", result.name);
+	return result;
+}
+
+void LogicalDependency::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<CatalogEntryInfo>(100, "entry", entry);
+	serializer.WritePropertyWithDefault<string>(101, "catalog", catalog);
+}
+
+LogicalDependency LogicalDependency::Deserialize(Deserializer &deserializer) {
+	LogicalDependency result;
+	deserializer.ReadProperty<CatalogEntryInfo>(100, "entry", result.entry);
+	deserializer.ReadPropertyWithDefault<string>(101, "catalog", result.catalog);
+	return result;
+}
+
+void LogicalDependencyList::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<create_info_set_t>(100, "set", set);
+}
+
+LogicalDependencyList LogicalDependencyList::Deserialize(Deserializer &deserializer) {
+	LogicalDependencyList result;
+	deserializer.ReadProperty<create_info_set_t>(100, "set", result.set);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_extension_install_info.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+
+namespace duckdb {
+
+void ExtensionInstallInfo::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty<ExtensionInstallMode>(100, "mode", mode);
+	serializer.WritePropertyWithDefault<string>(101, "full_path", full_path);
+	serializer.WritePropertyWithDefault<string>(102, "repository_url", repository_url);
+	serializer.WritePropertyWithDefault<string>(103, "version", version);
+}
+
+unique_ptr<ExtensionInstallInfo> ExtensionInstallInfo::Deserialize(Deserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ExtensionInstallInfo>(new ExtensionInstallInfo());
+	deserializer.ReadProperty<ExtensionInstallMode>(100, "mode", result->mode);
+	deserializer.ReadPropertyWithDefault<string>(101, "full_path", result->full_path);
+	deserializer.ReadPropertyWithDefault<string>(102, "repository_url", result->repository_url);
+	deserializer.ReadPropertyWithDefault<string>(103, "version", result->version);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp

@@ -172,6 +172,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_UPDATE:
 		result = LogicalUpdate::Deserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_VACUUM:
+		result = LogicalVacuum::Deserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_WINDOW:
 		result = LogicalWindow::Deserialize(deserializer);
 		break;
@@ -262,13 +265,13 @@ void LogicalColumnDataGet::Serialize(Serializer &serializer) const {
 	LogicalOperator::Serialize(serializer);
 	serializer.WritePropertyWithDefault<idx_t>(200, "table_index", table_index);
 	serializer.WritePropertyWithDefault<vector<LogicalType>>(201, "chunk_types", chunk_types);
-	serializer.WritePropertyWithDefault<unique_ptr<ColumnDataCollection>>(202, "collection", collection);
+	serializer.WritePropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection", collection);
 }
 
 unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
 	auto chunk_types = deserializer.ReadPropertyWithDefault<vector<LogicalType>>(201, "chunk_types");
-	auto collection = deserializer.ReadPropertyWithDefault<unique_ptr<ColumnDataCollection>>(202, "collection");
+	auto collection = deserializer.ReadPropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection");
 	auto result = duckdb::unique_ptr<LogicalColumnDataGet>(new LogicalColumnDataGet(table_index, std::move(chunk_types), std::move(collection)));
 	return std::move(result);
 }