duckdb 1.4.0 → 1.4.1

package/src/duckdb/src/storage/data_table.cpp

@@ -1542,7 +1542,7 @@ void DataTable::Update(TableUpdateState &state, ClientContext &context, Vector &
 		row_ids_slice.Slice(row_ids, sel_global_update, n_global_update);
 		row_ids_slice.Flatten(n_global_update);
 
-		row_groups->Update(transaction, FlatVector::GetData<row_t>(row_ids_slice), column_ids, updates_slice);
+		row_groups->Update(transaction, *this, FlatVector::GetData<row_t>(row_ids_slice), column_ids, updates_slice);
 	}
 }
 
@@ -1566,7 +1566,7 @@ void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, V
 
 	updates.Flatten();
 	row_ids.Flatten(updates.size());
-	row_groups->UpdateColumn(transaction, row_ids, column_path, updates);
+	row_groups->UpdateColumn(transaction, *this, row_ids, column_path, updates);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -563,7 +563,7 @@ void LocalStorage::Update(DataTable &table, Vector &row_ids, const vector<Physic
 	D_ASSERT(storage);
 
 	auto ids = FlatVector::GetData<row_t>(row_ids);
-	storage->row_groups->Update(TransactionData(0, 0), ids, column_ids, updates);
+	storage->row_groups->Update(TransactionData(0, 0), table, ids, column_ids, updates);
 }
 
 void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage, optional_ptr<StorageCommitState> commit_state) {

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

@@ -54,6 +54,8 @@ MetadataManager::~MetadataManager() {
 MetadataHandle MetadataManager::AllocateHandle() {
 	// check if there is any free space left in an existing block
 	// if not allocate a new block
+	MetadataPointer pointer;
+	unique_lock<mutex> guard(block_lock);
 	block_id_t free_block = INVALID_BLOCK;
 	for (auto &kv : blocks) {
 		auto &block = kv.second;
@@ -63,13 +65,16 @@ MetadataHandle MetadataManager::AllocateHandle() {
 			break;
 		}
 	}
+	guard.unlock();
 	if (free_block == INVALID_BLOCK || free_block > PeekNextBlockId()) {
-		free_block = AllocateNewBlock();
+		free_block = AllocateNewBlock(guard);
+	} else {
+		guard.lock();
 	}
+	D_ASSERT(guard.owns_lock());
 	D_ASSERT(free_block != INVALID_BLOCK);
 
 	// select the first free metadata block we can find
-	MetadataPointer pointer;
 	pointer.block_index = UnsafeNumericCast<idx_t>(free_block);
 	auto &block = blocks[free_block];
 	// the block is now dirty
@@ -77,7 +82,7 @@ MetadataHandle MetadataManager::AllocateHandle() {
 	if (block.block->BlockId() < MAXIMUM_BLOCK) {
 		// this block is a disk-backed block, yet we are planning to write to it
 		// we need to convert it into a transient block before we can write to it
-		ConvertToTransient(block);
+		ConvertToTransient(guard, block);
 		D_ASSERT(block.block->BlockId() >= MAXIMUM_BLOCK);
 	}
 	D_ASSERT(!block.free_blocks.empty());
@@ -85,6 +90,7 @@ MetadataHandle MetadataManager::AllocateHandle() {
 	// mark the block as used
 	block.free_blocks.pop_back();
 	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
+	guard.unlock();
 	// pin the block
 	return Pin(pointer);
 }
@@ -95,25 +101,34 @@ MetadataHandle MetadataManager::Pin(const MetadataPointer &pointer) {
 
 MetadataHandle MetadataManager::Pin(QueryContext context, const MetadataPointer &pointer) {
 	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
-	auto &block = blocks[UnsafeNumericCast<int64_t>(pointer.block_index)];
+	shared_ptr<BlockHandle> block_handle;
+	{
+		lock_guard<mutex> guard(block_lock);
+		auto &block = blocks[UnsafeNumericCast<int64_t>(pointer.block_index)];
 #ifdef DEBUG
-	for (auto &free_block : block.free_blocks) {
-		if (free_block == pointer.index) {
-			throw InternalException("Pinning block %d.%d but it is marked as a free block", block.block_id, free_block);
+		for (auto &free_block : block.free_blocks) {
+			if (free_block == pointer.index) {
+				throw InternalException("Pinning block %d.%d but it is marked as a free block", block.block_id,
+				                        free_block);
+			}
 		}
-	}
 #endif
+		block_handle = block.block;
+	}
 
 	MetadataHandle handle;
 	handle.pointer.block_index = pointer.block_index;
 	handle.pointer.index = pointer.index;
-	handle.handle = buffer_manager.Pin(block.block);
+	handle.handle = buffer_manager.Pin(block_handle);
 	return handle;
 }
 
-void MetadataManager::ConvertToTransient(MetadataBlock &metadata_block) {
+void MetadataManager::ConvertToTransient(unique_lock<mutex> &block_lock, MetadataBlock &metadata_block) {
+	D_ASSERT(block_lock.owns_lock());
+	auto old_block = metadata_block.block;
+	block_lock.unlock();
 	// pin the old block
-	auto old_buffer = buffer_manager.Pin(metadata_block.block);
+	auto old_buffer = buffer_manager.Pin(old_block);
 
 	// allocate a new transient block to replace it
 	auto new_buffer = buffer_manager.Allocate(MemoryTag::METADATA, &block_manager, false);
@@ -121,14 +136,17 @@ void MetadataManager::ConvertToTransient(MetadataBlock &metadata_block) {
 
 	// copy the data to the transient block
 	memcpy(new_buffer.Ptr(), old_buffer.Ptr(), block_manager.GetBlockSize());
-	metadata_block.block = std::move(new_block);
-	metadata_block.dirty = true;
 
 	// unregister the old block
 	block_manager.UnregisterBlock(metadata_block.block_id);
+
+	block_lock.lock();
+	metadata_block.block = std::move(new_block);
+	metadata_block.dirty = true;
 }
 
-block_id_t MetadataManager::AllocateNewBlock() {
+block_id_t MetadataManager::AllocateNewBlock(unique_lock<mutex> &block_lock) {
+	D_ASSERT(!block_lock.owns_lock());
 	auto new_block_id = GetNextBlockId();
 
 	MetadataBlock new_block;
@@ -141,11 +159,14 @@ block_id_t MetadataManager::AllocateNewBlock() {
 	new_block.dirty = true;
 	// zero-initialize the handle
 	memset(handle.Ptr(), 0, block_manager.GetBlockSize());
-	AddBlock(std::move(new_block));
+
+	block_lock.lock();
+	AddBlock(block_lock, std::move(new_block));
 	return new_block_id;
 }
 
-void MetadataManager::AddBlock(MetadataBlock new_block, bool if_exists) {
+void MetadataManager::AddBlock(unique_lock<mutex> &block_lock, MetadataBlock new_block, bool if_exists) {
+	D_ASSERT(block_lock.owns_lock());
 	if (blocks.find(new_block.block_id) != blocks.end()) {
 		if (if_exists) {
 			return;
@@ -155,15 +176,17 @@ void MetadataManager::AddBlock(MetadataBlock new_block, bool if_exists) {
 	blocks[new_block.block_id] = std::move(new_block);
 }
 
-void MetadataManager::AddAndRegisterBlock(MetadataBlock block) {
+void MetadataManager::AddAndRegisterBlock(unique_lock<mutex> &block_lock, MetadataBlock block) {
 	if (block.block) {
 		throw InternalException("Calling AddAndRegisterBlock on block that already exists");
 	}
 	if (block.block_id >= MAXIMUM_BLOCK) {
 		throw InternalException("AddAndRegisterBlock called with a transient block id");
 	}
+	block_lock.unlock();
 	block.block = block_manager.RegisterBlock(block.block_id);
-	AddBlock(std::move(block), true);
+	block_lock.lock();
+	AddBlock(block_lock, std::move(block), true);
 }
 
 MetaBlockPointer MetadataManager::GetDiskPointer(const MetadataPointer &pointer, uint32_t offset) {
@@ -181,8 +204,14 @@ uint32_t MetaBlockPointer::GetBlockIndex() const {
 }
 
 MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) {
+	unique_lock<mutex> guard(block_lock);
+	return FromDiskPointerInternal(guard, pointer);
+}
+
+MetadataPointer MetadataManager::FromDiskPointerInternal(unique_lock<mutex> &block_lock, MetaBlockPointer pointer) {
 	auto block_id = pointer.GetBlockId();
 	auto index = pointer.GetBlockIndex();
+
 	auto entry = blocks.find(block_id);
 	if (entry == blocks.end()) { // LCOV_EXCL_START
 		throw InternalException("Failed to load metadata pointer (id %llu, idx %llu, ptr %llu)\n", block_id, index,
@@ -195,11 +224,13 @@ MetadataPointer MetadataManager::FromDiskPointer(MetaBlockPointer pointer) {
 }
 
 MetadataPointer MetadataManager::RegisterDiskPointer(MetaBlockPointer pointer) {
+	unique_lock<mutex> guard(block_lock);
+
 	auto block_id = pointer.GetBlockId();
 	MetadataBlock block;
 	block.block_id = block_id;
-	AddAndRegisterBlock(std::move(block));
-	return FromDiskPointer(pointer);
+	AddAndRegisterBlock(guard, std::move(block));
+	return FromDiskPointerInternal(guard, pointer);
 }
 
 BlockPointer MetadataManager::ToBlockPointer(MetaBlockPointer meta_pointer, const idx_t metadata_block_size) {
@@ -232,6 +263,7 @@ void MetadataManager::Flush() {
 	// Write the blocks of the metadata manager to disk.
 	const idx_t total_metadata_size = GetMetadataBlockSize() * METADATA_BLOCK_COUNT;
 
+	unique_lock<mutex> guard(block_lock, std::defer_lock);
 	for (auto &kv : blocks) {
 		auto &block = kv.second;
 		if (!block.dirty) {
@@ -245,9 +277,13 @@ void MetadataManager::Flush() {
 		memset(handle.Ptr() + total_metadata_size, 0, block_manager.GetBlockSize() - total_metadata_size);
 		D_ASSERT(kv.first == block.block_id);
 		if (block.block->BlockId() >= MAXIMUM_BLOCK) {
+			auto new_block =
+			    block_manager.ConvertToPersistent(QueryContext(), kv.first, block.block, std::move(handle));
+
 			// Convert the temporary block to a persistent block.
-			block.block =
-			    block_manager.ConvertToPersistent(QueryContext(), kv.first, std::move(block.block), std::move(handle));
+			guard.lock();
+			block.block = std::move(new_block);
+			guard.unlock();
 		} else {
 			// Already a persistent block, so we only need to write it.
 			D_ASSERT(block.block->BlockId() == block.block_id);
@@ -269,10 +305,12 @@ void MetadataManager::Read(ReadStream &source) {
 	auto block_count = source.Read<uint64_t>();
 	for (idx_t i = 0; i < block_count; i++) {
 		auto block = MetadataBlock::Read(source);
+
+		unique_lock<mutex> guard(block_lock);
 		auto entry = blocks.find(block.block_id);
 		if (entry == blocks.end()) {
 			// block does not exist yet
-			AddAndRegisterBlock(std::move(block));
+			AddAndRegisterBlock(guard, std::move(block));
 		} else {
 			// block was already created - only copy over the free list
 			entry->second.free_blocks = std::move(block.free_blocks);
@@ -349,6 +387,7 @@ void MetadataManager::MarkBlocksAsModified() {
 	}
 
 	modified_blocks.clear();
+
 	for (auto &kv : blocks) {
 		auto &block = kv.second;
 		idx_t free_list = block.FreeBlocksToInteger();
@@ -361,6 +400,7 @@ void MetadataManager::ClearModifiedBlocks(const vector<MetaBlockPointer> &pointe
 	if (pointers.empty()) {
 		return;
 	}
+	unique_lock<mutex> guard(block_lock);
 	for (auto &pointer : pointers) {
 		auto block_id = pointer.GetBlockId();
 		auto block_index = pointer.GetBlockIndex();
@@ -376,6 +416,7 @@ void MetadataManager::ClearModifiedBlocks(const vector<MetaBlockPointer> &pointe
 
 vector<MetadataBlockInfo> MetadataManager::GetMetadataInfo() const {
 	vector<MetadataBlockInfo> result;
+	unique_lock<mutex> guard(block_lock);
 	for (auto &block : blocks) {
 		MetadataBlockInfo block_info;
 		block_info.block_id = block.second.block_id;
@@ -393,17 +434,18 @@ vector<MetadataBlockInfo> MetadataManager::GetMetadataInfo() const {
 
 vector<shared_ptr<BlockHandle>> MetadataManager::GetBlocks() const {
 	vector<shared_ptr<BlockHandle>> result;
+	unique_lock<mutex> guard(block_lock);
 	for (auto &entry : blocks) {
 		result.push_back(entry.second.block);
 	}
 	return result;
 }
 
-block_id_t MetadataManager::PeekNextBlockId() {
+block_id_t MetadataManager::PeekNextBlockId() const {
 	return block_manager.PeekFreeBlockId();
 }
 
-block_id_t MetadataManager::GetNextBlockId() {
+block_id_t MetadataManager::GetNextBlockId() const {
 	return block_manager.GetFreeBlockId();
 }
 

package/src/duckdb/src/storage/statistics/string_stats.cpp

@@ -170,6 +170,14 @@ void StringStats::Update(BaseStatistics &stats, const string_t &value) {
 	}
 }
 
+void StringStats::SetMin(BaseStatistics &stats, const string_t &value) {
+	ConstructValue(const_data_ptr_cast(value.GetData()), value.GetSize(), GetDataUnsafe(stats).min);
+}
+
+void StringStats::SetMax(BaseStatistics &stats, const string_t &value) {
+	ConstructValue(const_data_ptr_cast(value.GetData()), value.GetSize(), GetDataUnsafe(stats).max);
+}
+
 void StringStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 	if (other.GetType().id() == LogicalTypeId::VALIDITY) {
 		return;

package/src/duckdb/src/storage/table/array_column_data.cpp

@@ -97,7 +97,7 @@ idx_t ArrayColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t c
 
 void ArrayColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
                              SelectionVector &sel, idx_t sel_count) {
-	bool is_supported = !child_column->type.IsNested();
+	bool is_supported = !child_column->type.IsNested() && child_column->type.InternalType() != PhysicalType::VARCHAR;
 	if (!is_supported) {
 		ColumnData::Select(transaction, vector_index, state, result, sel, sel_count);
 		return;
@@ -224,13 +224,14 @@ idx_t ArrayColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &resul
 	throw NotImplementedException("Array Fetch");
 }
 
-void ArrayColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                             idx_t update_count) {
+void ArrayColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                             Vector &update_vector, row_t *row_ids, idx_t update_count) {
 	throw NotImplementedException("Array Update is not supported.");
 }
 
-void ArrayColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                   Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
+void ArrayColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table,
+                                   const vector<column_t> &column_path, Vector &update_vector, row_t *row_ids,
+                                   idx_t update_count, idx_t depth) {
 	throw NotImplementedException("Array Update Column is not supported");
 }
 

package/src/duckdb/src/storage/table/column_data.cpp

@@ -293,13 +293,13 @@ void ColumnData::FetchUpdateRow(TransactionData transaction, row_t row_id, Vecto
 	updates->FetchRow(transaction, NumericCast<idx_t>(row_id), result, result_idx);
 }
 
-void ColumnData::UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t update_count, Vector &base_vector) {
+void ColumnData::UpdateInternal(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                                Vector &update_vector, row_t *row_ids, idx_t update_count, Vector &base_vector) {
 	lock_guard<mutex> update_guard(update_lock);
 	if (!updates) {
 		updates = make_uniq<UpdateSegment>(*this);
 	}
-	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
+	updates->Update(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
 idx_t ColumnData::ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
@@ -578,20 +578,20 @@ idx_t ColumnData::FetchUpdateData(ColumnScanState &state, row_t *row_ids, Vector
 	return fetch_count;
 }
 
-void ColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                        idx_t update_count) {
+void ColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+                        row_t *row_ids, idx_t update_count) {
 	Vector base_vector(type);
 	ColumnScanState state;
 	FetchUpdateData(state, row_ids, base_vector);
 
-	UpdateInternal(transaction, column_index, update_vector, row_ids, update_count, base_vector);
+	UpdateInternal(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
-void ColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-                              row_t *row_ids, idx_t update_count, idx_t depth) {
+void ColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+                              Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
 	// this method should only be called at the end of the path in the base column case
 	D_ASSERT(depth >= column_path.size());
-	ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
+	ColumnData::Update(transaction, data_table, column_path[0], update_vector, row_ids, update_count);
 }
 
 void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
@@ -873,6 +873,17 @@ PersistentColumnData ColumnData::Serialize() {
 	return result;
 }
 
+void RealignColumnData(PersistentColumnData &column_data, idx_t new_start) {
+	idx_t current_start = new_start;
+	for (auto &pointer : column_data.pointers) {
+		pointer.row_start = current_start;
+		current_start += pointer.tuple_count;
+	}
+	for (auto &child : column_data.child_columns) {
+		RealignColumnData(child, new_start);
+	}
+}
+
 shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
                                                idx_t start_row, ReadStream &source, const LogicalType &type) {
 	auto entry = ColumnData::CreateColumn(block_manager, info, column_index, start_row, type, nullptr);
@@ -890,6 +901,9 @@ shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, Data
 	deserializer.Unset<DatabaseInstance>();
 	deserializer.End();
 
+	// re-align data segments, in case our start_row has changed
+	RealignColumnData(persistent_column_data, start_row);
+
 	// initialize the column
 	entry->InitializeColumn(persistent_column_data, entry->stats->statistics);
 	return entry;

package/src/duckdb/src/storage/table/column_data_checkpointer.cpp

@@ -376,8 +376,22 @@ void ColumnDataCheckpointer::WritePersistentSegments(ColumnCheckpointState &stat
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
 		auto segment = nodes[segment_idx].node.get();
 		if (segment->start != current_row) {
+			string extra_info;
+			for (auto &s : nodes) {
+				extra_info += "\n";
+				extra_info += StringUtil::Format("Start %d, count %d", s.node->start, s.node->count.load());
+			}
+			const_reference<ColumnData> root = col_data;
+			while (root.get().HasParent()) {
+				root = root.get().Parent();
+			}
 			throw InternalException(
-			    "Failure in RowGroup::Checkpoint - column data pointer is unaligned with row group start");
+			    "Failure in RowGroup::Checkpoint - column data pointer is unaligned with row group "
+			    "start\nRow group start: %d\nRow group count %d\nCurrent row: %d\nSegment start: %d\nColumn index: "
+			    "%d\nColumn type: %s\nRoot type: %s\nTable: %s.%s\nAll segments:%s",
+			    row_group.start, row_group.count.load(), current_row, segment->start, root.get().column_index,
+			    col_data.type, root.get().type, root.get().info.GetSchemaName(), root.get().info.GetTableName(),
+			    extra_info);
 		}
 		current_row += segment->count;
 		auto pointer = segment->GetDataPointer();

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -263,13 +263,14 @@ idx_t ListColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result
 	throw NotImplementedException("List Fetch");
 }
 
-void ListColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                            idx_t update_count) {
+void ListColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                            Vector &update_vector, row_t *row_ids, idx_t update_count) {
 	throw NotImplementedException("List Update is not supported.");
 }
 
-void ListColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
+void ListColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table,
+                                  const vector<column_t> &column_path, Vector &update_vector, row_t *row_ids,
+                                  idx_t update_count, idx_t depth) {
 	throw NotImplementedException("List Update Column is not supported");
 }
 

package/src/duckdb/src/storage/table/row_group.cpp

@@ -859,8 +859,8 @@ void RowGroup::CleanupAppend(transaction_t lowest_transaction, idx_t start, idx_
 	vinfo.CleanupAppend(lowest_transaction, start, count);
 }
 
-void RowGroup::Update(TransactionData transaction, DataChunk &update_chunk, row_t *ids, idx_t offset, idx_t count,
-                      const vector<PhysicalIndex> &column_ids) {
+void RowGroup::Update(TransactionData transaction, DataTable &data_table, DataChunk &update_chunk, row_t *ids,
+                      idx_t offset, idx_t count, const vector<PhysicalIndex> &column_ids) {
 #ifdef DEBUG
 	for (size_t i = offset; i < offset + count; i++) {
 		D_ASSERT(ids[i] >= row_t(this->start) && ids[i] < row_t(this->start + this->count));
@@ -873,16 +873,16 @@ void RowGroup::Update(TransactionData transaction, DataChunk &update_chunk, row_
 		if (offset > 0) {
 			Vector sliced_vector(update_chunk.data[i], offset, offset + count);
 			sliced_vector.Flatten(count);
-			col_data.Update(transaction, column.index, sliced_vector, ids + offset, count);
+			col_data.Update(transaction, data_table, column.index, sliced_vector, ids + offset, count);
 		} else {
-			col_data.Update(transaction, column.index, update_chunk.data[i], ids, count);
+			col_data.Update(transaction, data_table, column.index, update_chunk.data[i], ids, count);
 		}
 		MergeStatistics(column.index, *col_data.GetUpdateStatistics());
 	}
 }
 
-void RowGroup::UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids, idx_t offset, idx_t count,
-                            const vector<column_t> &column_path) {
+void RowGroup::UpdateColumn(TransactionData transaction, DataTable &data_table, DataChunk &updates, Vector &row_ids,
+                            idx_t offset, idx_t count, const vector<column_t> &column_path) {
 	D_ASSERT(updates.ColumnCount() == 1);
 	auto ids = FlatVector::GetData<row_t>(row_ids);
 
@@ -892,9 +892,9 @@ void RowGroup::UpdateColumn(TransactionData transaction, DataChunk &updates, Vec
 	if (offset > 0) {
 		Vector sliced_vector(updates.data[0], offset, offset + count);
 		sliced_vector.Flatten(count);
-		col_data.UpdateColumn(transaction, column_path, sliced_vector, ids + offset, count, 1);
+		col_data.UpdateColumn(transaction, data_table, column_path, sliced_vector, ids + offset, count, 1);
 	} else {
-		col_data.UpdateColumn(transaction, column_path, updates.data[0], ids, count, 1);
+		col_data.UpdateColumn(transaction, data_table, column_path, updates.data[0], ids, count, 1);
 	}
 	MergeStatistics(primary_column_idx, *col_data.GetUpdateStatistics());
 }

package/src/duckdb/src/storage/table/row_group_collection.cpp

@@ -645,14 +645,14 @@ optional_ptr<RowGroup> RowGroupCollection::NextUpdateRowGroup(row_t *ids, idx_t
 	return row_group;
 }
 
-void RowGroupCollection::Update(TransactionData transaction, row_t *ids, const vector<PhysicalIndex> &column_ids,
-                                DataChunk &updates) {
+void RowGroupCollection::Update(TransactionData transaction, DataTable &data_table, row_t *ids,
+                                const vector<PhysicalIndex> &column_ids, DataChunk &updates) {
 	D_ASSERT(updates.size() >= 1);
 	idx_t pos = 0;
 	do {
 		idx_t start = pos;
 		auto row_group = NextUpdateRowGroup(ids, pos, updates.size());
-		row_group->Update(transaction, updates, ids, start, pos - start, column_ids);
+		row_group->Update(transaction, data_table, updates, ids, start, pos - start, column_ids);
 
 		auto l = stats.GetLock();
 		for (idx_t i = 0; i < column_ids.size(); i++) {
@@ -764,15 +764,15 @@ void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_
 	}
 }
 
-void RowGroupCollection::UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
-                                      DataChunk &updates) {
+void RowGroupCollection::UpdateColumn(TransactionData transaction, DataTable &data_table, Vector &row_ids,
+                                      const vector<column_t> &column_path, DataChunk &updates) {
 	D_ASSERT(updates.size() >= 1);
 	auto ids = FlatVector::GetData<row_t>(row_ids);
 	idx_t pos = 0;
 	do {
 		idx_t start = pos;
 		auto row_group = NextUpdateRowGroup(ids, pos, updates.size());
-		row_group->UpdateColumn(transaction, updates, row_ids, start, pos - start, column_path);
+		row_group->UpdateColumn(transaction, data_table, updates, row_ids, start, pos - start, column_path);
 
 		auto lock = stats.GetLock();
 		auto primary_column_idx = column_path[0];
@@ -1008,8 +1008,8 @@ bool RowGroupCollection::ScheduleVacuumTasks(CollectionCheckpointState &checkpoi
 	}
 	idx_t merge_rows;
 	idx_t next_idx = 0;
-	idx_t merge_count;
-	idx_t target_count;
+	idx_t merge_count = 0;
+	idx_t target_count = 0;
 	bool perform_merge = false;
 	// check if we can merge row groups adjacent to the current segment_idx
 	// we try merging row groups into batches of 1-3 row groups
@@ -1061,6 +1061,8 @@ bool RowGroupCollection::ScheduleVacuumTasks(CollectionCheckpointState &checkpoi
 		return false;
 	}
 	// schedule the vacuum task
+	DUCKDB_LOG(checkpoint_state.writer.GetDatabase(), CheckpointLogType, GetAttached(), *info, segment_idx, merge_count,
+	           target_count, merge_rows, state.row_start);
 	auto vacuum_task = make_uniq<VacuumTask>(checkpoint_state, state, segment_idx, merge_count, target_count,
 	                                         merge_rows, state.row_start);
 	checkpoint_state.executor->ScheduleTask(std::move(vacuum_task));
@@ -1107,6 +1109,8 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl
 			// schedule a checkpoint task for this row group
 			entry.node->MoveToCollection(*this, vacuum_state.row_start);
 			if (writer.GetCheckpointType() != CheckpointType::VACUUM_ONLY) {
+				DUCKDB_LOG(checkpoint_state.writer.GetDatabase(), CheckpointLogType, GetAttached(), *info, segment_idx,
+				           *entry.node);
 				auto checkpoint_task = GetCheckpointTask(checkpoint_state, segment_idx);
 				checkpoint_state.executor->ScheduleTask(std::move(checkpoint_task));
 			}

package/src/duckdb/src/storage/table/row_id_column_data.cpp

@@ -138,13 +138,14 @@ void RowIdColumnData::RevertAppend(row_t start_row) {
 	throw InternalException("RowIdColumnData cannot be appended to");
 }
 
-void RowIdColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                             idx_t update_count) {
+void RowIdColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                             Vector &update_vector, row_t *row_ids, idx_t update_count) {
 	throw InternalException("RowIdColumnData cannot be updated");
 }
 
-void RowIdColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                   Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
+void RowIdColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table,
+                                   const vector<column_t> &column_path, Vector &update_vector, row_t *row_ids,
+                                   idx_t update_count, idx_t depth) {
 	throw InternalException("RowIdColumnData cannot be updated");
 }
 

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -152,8 +152,8 @@ idx_t StandardColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &re
 	return scan_count;
 }
 
-void StandardColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t update_count) {
+void StandardColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                                Vector &update_vector, row_t *row_ids, idx_t update_count) {
 	ColumnScanState standard_state, validity_state;
 	Vector base_vector(type);
 	auto standard_fetch = FetchUpdateData(standard_state, row_ids, base_vector);
@@ -162,18 +162,19 @@ void StandardColumnData::Update(TransactionData transaction, idx_t column_index,
 		throw InternalException("Unaligned fetch in validity and main column data for update");
 	}
 
-	UpdateInternal(transaction, column_index, update_vector, row_ids, update_count, base_vector);
-	validity.UpdateInternal(transaction, column_index, update_vector, row_ids, update_count, base_vector);
+	UpdateInternal(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector);
+	validity.UpdateInternal(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
-void StandardColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                      Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
+void StandardColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table,
+                                      const vector<column_t> &column_path, Vector &update_vector, row_t *row_ids,
+                                      idx_t update_count, idx_t depth) {
 	if (depth >= column_path.size()) {
 		// update this column
-		ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
+		ColumnData::Update(transaction, data_table, column_path[0], update_vector, row_ids, update_count);
 	} else {
 		// update the child column (i.e. the validity column)
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
+		validity.UpdateColumn(transaction, data_table, column_path, update_vector, row_ids, update_count, depth + 1);
 	}
 }
 

package/src/duckdb/src/storage/table/struct_column_data.cpp

@@ -207,17 +207,18 @@ idx_t StructColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &resu
 	return scan_count;
 }
 
-void StructColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                              idx_t update_count) {
-	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
+void StructColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index,
+                              Vector &update_vector, row_t *row_ids, idx_t update_count) {
+	validity.Update(transaction, data_table, column_index, update_vector, row_ids, update_count);
 	auto &child_entries = StructVector::GetEntries(update_vector);
 	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Update(transaction, column_index, *child_entries[i], row_ids, update_count);
+		sub_columns[i]->Update(transaction, data_table, column_index, *child_entries[i], row_ids, update_count);
 	}
 }
 
-void StructColumnData::UpdateColumn(TransactionData transaction, const vector<column_t> &column_path,
-                                    Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
+void StructColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table,
+                                    const vector<column_t> &column_path, Vector &update_vector, row_t *row_ids,
+                                    idx_t update_count, idx_t depth) {
 	// we can never DIRECTLY update a struct column
 	if (depth >= column_path.size()) {
 		throw InternalException("Attempting to directly update a struct column - this should not be possible");
@@ -225,13 +226,13 @@ void StructColumnData::UpdateColumn(TransactionData transaction, const vector<co
 	auto update_column = column_path[depth];
 	if (update_column == 0) {
 		// update the validity column
-		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
+		validity.UpdateColumn(transaction, data_table, column_path, update_vector, row_ids, update_count, depth + 1);
 	} else {
 		if (update_column > sub_columns.size()) {
 			throw InternalException("Update column_path out of range");
 		}
-		sub_columns[update_column - 1]->UpdateColumn(transaction, column_path, update_vector, row_ids, update_count,
-		                                             depth + 1);
+		sub_columns[update_column - 1]->UpdateColumn(transaction, data_table, column_path, update_vector, row_ids,
+		                                             update_count, depth + 1);
 	}
 }