duckdb 0.8.2-dev87.0 → 0.9.0

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

@@ -0,0 +1,322 @@
+#include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
+#include "duckdb/common/serializer/read_stream.hpp"
+#include "duckdb/storage/database_size.hpp"
+
+namespace duckdb {
+
+MetadataManager::MetadataManager(BlockManager &block_manager, BufferManager &buffer_manager)
+    : block_manager(block_manager), buffer_manager(buffer_manager) {
+}
+
+MetadataManager::~MetadataManager() {
+}
+
+MetadataHandle MetadataManager::AllocateHandle() {
+	// check if there is any free space left in an existing block
+	// if not allocate a new block
+	block_id_t free_block = INVALID_BLOCK;
+	for (auto &kv : blocks) {
+		auto &block = kv.second;
+		D_ASSERT(kv.first == block.block_id);
+		if (!block.free_blocks.empty()) {
+			free_block = kv.first;
+			break;
+		}
+	}
+	if (free_block == INVALID_BLOCK) {
+		free_block = AllocateNewBlock();
+	}
+	D_ASSERT(free_block != INVALID_BLOCK);
+
+	// select the first free metadata block we can find
+	MetadataPointer pointer;
+	pointer.block_index = 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
+		// we need to convert it into a transient block before we can write to it
+		ConvertToTransient(block);
+		D_ASSERT(block.block->BlockId() >= MAXIMUM_BLOCK);
+	}
+	D_ASSERT(!block.free_blocks.empty());
+	pointer.index = block.free_blocks.back();
+	// mark the block as used
+	block.free_blocks.pop_back();
+	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
+	// pin the block
+	return Pin(pointer);
+}
+
+MetadataHandle MetadataManager::Pin(MetadataPointer pointer) {
+	D_ASSERT(pointer.index < METADATA_BLOCK_COUNT);
+	auto &block = blocks[pointer.block_index];
+
+	MetadataHandle handle;
+	handle.pointer.block_index = pointer.block_index;
+	handle.pointer.index = pointer.index;
+	handle.handle = buffer_manager.Pin(block.block);
+	return handle;
+}
+
+void MetadataManager::ConvertToTransient(MetadataBlock &block) {
+	// pin the old block
+	auto old_buffer = buffer_manager.Pin(block.block);
+
+	// allocate a new transient block to replace it
+	shared_ptr<BlockHandle> new_block;
+	auto new_buffer = buffer_manager.Allocate(Storage::BLOCK_SIZE, false, &new_block);
+
+	// copy the data to the transient block
+	memcpy(new_buffer.Ptr(), old_buffer.Ptr(), Storage::BLOCK_SIZE);
+
+	block.block = std::move(new_block);
+
+	// unregister the old block
+	block_manager.UnregisterBlock(block.block_id, false);
+}
+
+block_id_t MetadataManager::AllocateNewBlock() {
+	auto new_block_id = GetNextBlockId();
+
+	MetadataBlock new_block;
+	auto handle = buffer_manager.Allocate(Storage::BLOCK_SIZE, false, &new_block.block);
+	new_block.block_id = new_block_id;
+	for (idx_t i = 0; i < METADATA_BLOCK_COUNT; i++) {
+		new_block.free_blocks.push_back(METADATA_BLOCK_COUNT - i - 1);
+	}
+	// zero-initialize the handle
+	memset(handle.Ptr(), 0, Storage::BLOCK_SIZE);
+	AddBlock(std::move(new_block));
+	return new_block_id;
+}
+
+void MetadataManager::AddBlock(MetadataBlock new_block, bool if_exists) {
+	if (blocks.find(new_block.block_id) != blocks.end()) {
+		if (if_exists) {
+			return;
+		}
+		throw InternalException("Block id with id %llu already exists", new_block.block_id);
+	}
+	blocks[new_block.block_id] = std::move(new_block);
+}
+
+void MetadataManager::AddAndRegisterBlock(MetadataBlock block) {
+	if (block.block) {
+		throw InternalException("Calling AddAndRegisterBlock on block that already exists");
+	}
+	block.block = block_manager.RegisterBlock(block.block_id);
+	AddBlock(std::move(block), true);
+}
+
+MetaBlockPointer MetadataManager::GetDiskPointer(MetadataPointer pointer, uint32_t offset) {
+	idx_t block_pointer = idx_t(pointer.block_index);
+	block_pointer |= idx_t(pointer.index) << 56ULL;
+	return MetaBlockPointer(block_pointer, offset);
+}
+
+block_id_t MetaBlockPointer::GetBlockId() const {
+	return block_id_t(block_pointer & ~(idx_t(0xFF) << 56ULL));
+}
+
+uint32_t MetaBlockPointer::GetBlockIndex() const {
+	return block_pointer >> 56ULL;
+}
+
+MetadataPointer MetadataManager::FromDiskPointer(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,
+		                        pointer.block_pointer);
+	} // LCOV_EXCL_STOP
+	MetadataPointer result;
+	result.block_index = block_id;
+	result.index = index;
+	return result;
+}
+
+MetadataPointer MetadataManager::RegisterDiskPointer(MetaBlockPointer pointer) {
+	auto block_id = pointer.GetBlockId();
+	MetadataBlock block;
+	block.block_id = block_id;
+	AddAndRegisterBlock(block);
+	return FromDiskPointer(pointer);
+}
+
+BlockPointer MetadataManager::ToBlockPointer(MetaBlockPointer meta_pointer) {
+	BlockPointer result;
+	result.block_id = meta_pointer.GetBlockId();
+	result.offset = meta_pointer.GetBlockIndex() * MetadataManager::METADATA_BLOCK_SIZE + meta_pointer.offset;
+	D_ASSERT(result.offset < MetadataManager::METADATA_BLOCK_SIZE * MetadataManager::METADATA_BLOCK_COUNT);
+	return result;
+}
+
+MetaBlockPointer MetadataManager::FromBlockPointer(BlockPointer block_pointer) {
+	if (!block_pointer.IsValid()) {
+		return MetaBlockPointer();
+	}
+	idx_t index = block_pointer.offset / MetadataManager::METADATA_BLOCK_SIZE;
+	auto offset = block_pointer.offset % MetadataManager::METADATA_BLOCK_SIZE;
+	D_ASSERT(index < MetadataManager::METADATA_BLOCK_COUNT);
+	D_ASSERT(offset < MetadataManager::METADATA_BLOCK_SIZE);
+	MetaBlockPointer result;
+	result.block_pointer = idx_t(block_pointer.block_id) | index << 56ULL;
+	result.offset = offset;
+	return result;
+}
+
+idx_t MetadataManager::BlockCount() {
+	return blocks.size();
+}
+
+void MetadataManager::Flush() {
+	const idx_t total_metadata_size = MetadataManager::METADATA_BLOCK_SIZE * MetadataManager::METADATA_BLOCK_COUNT;
+	// write the blocks of the metadata manager to disk
+	for (auto &kv : blocks) {
+		auto &block = kv.second;
+		auto handle = buffer_manager.Pin(block.block);
+		// there are a few bytes left-over at the end of the block, zero-initialize them
+		memset(handle.Ptr() + total_metadata_size, 0, Storage::BLOCK_SIZE - total_metadata_size);
+		D_ASSERT(kv.first == block.block_id);
+		if (block.block->BlockId() >= MAXIMUM_BLOCK) {
+			// temporary block - convert to persistent
+			block.block = block_manager.ConvertToPersistent(kv.first, std::move(block.block));
+		} else {
+			// already a persistent block - only need to write it
+			D_ASSERT(block.block->BlockId() == block.block_id);
+			block_manager.Write(handle.GetFileBuffer(), block.block_id);
+		}
+	}
+}
+
+void MetadataManager::Write(WriteStream &sink) {
+	sink.Write<uint64_t>(blocks.size());
+	for (auto &kv : blocks) {
+		kv.second.Write(sink);
+	}
+}
+
+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);
+		auto entry = blocks.find(block.block_id);
+		if (entry == blocks.end()) {
+			// block does not exist yet
+			AddAndRegisterBlock(std::move(block));
+		} else {
+			// block was already created - only copy over the free list
+			entry->second.free_blocks = std::move(block.free_blocks);
+		}
+	}
+}
+
+void MetadataBlock::Write(WriteStream &sink) {
+	sink.Write<block_id_t>(block_id);
+	sink.Write<idx_t>(FreeBlocksToInteger());
+}
+
+MetadataBlock MetadataBlock::Read(ReadStream &source) {
+	MetadataBlock result;
+	result.block_id = source.Read<block_id_t>();
+	auto free_list = source.Read<idx_t>();
+	result.FreeBlocksFromInteger(free_list);
+	return result;
+}
+
+idx_t MetadataBlock::FreeBlocksToInteger() {
+	idx_t result = 0;
+	for (idx_t i = 0; i < free_blocks.size(); i++) {
+		D_ASSERT(free_blocks[i] < idx_t(64));
+		idx_t mask = idx_t(1) << idx_t(free_blocks[i]);
+		result |= mask;
+	}
+	return result;
+}
+
+void MetadataBlock::FreeBlocksFromInteger(idx_t free_list) {
+	free_blocks.clear();
+	if (free_list == 0) {
+		return;
+	}
+	for (idx_t i = 64; i > 0; i--) {
+		auto index = i - 1;
+		idx_t mask = idx_t(1) << index;
+		if (free_list & mask) {
+			free_blocks.push_back(index);
+		}
+	}
+}
+
+void MetadataManager::MarkBlocksAsModified() {
+	// for any blocks that were modified in the last checkpoint - set them to free blocks currently
+	for (auto &kv : modified_blocks) {
+		auto block_id = kv.first;
+		idx_t modified_list = kv.second;
+		auto entry = blocks.find(block_id);
+		D_ASSERT(entry != blocks.end());
+		auto &block = entry->second;
+		idx_t current_free_blocks = block.FreeBlocksToInteger();
+		// merge the current set of free blocks with the modified blocks
+		idx_t new_free_blocks = current_free_blocks | modified_list;
+		if (new_free_blocks == NumericLimits<idx_t>::Maximum()) {
+			// if new free_blocks is all blocks - mark entire block as modified
+			blocks.erase(entry);
+			block_manager.MarkBlockAsModified(block_id);
+		} else {
+			// set the new set of free blocks
+			block.FreeBlocksFromInteger(new_free_blocks);
+		}
+	}
+
+	modified_blocks.clear();
+	for (auto &kv : blocks) {
+		auto &block = kv.second;
+		idx_t free_list = block.FreeBlocksToInteger();
+		idx_t occupied_list = ~free_list;
+		modified_blocks[block.block_id] = occupied_list;
+	}
+}
+
+void MetadataManager::ClearModifiedBlocks(const vector<MetaBlockPointer> &pointers) {
+	for (auto &pointer : pointers) {
+		auto block_id = pointer.GetBlockId();
+		auto block_index = pointer.GetBlockIndex();
+		auto entry = modified_blocks.find(block_id);
+		if (entry == modified_blocks.end()) {
+			throw InternalException("ClearModifiedBlocks - Block id %llu not found in modified_blocks", block_id);
+		}
+		auto &modified_list = entry->second;
+		// verify the block has been modified
+		D_ASSERT(modified_list && (1ULL << block_index));
+		// unset the bit
+		modified_list &= ~(1ULL << block_index);
+	}
+}
+
+vector<MetadataBlockInfo> MetadataManager::GetMetadataInfo() const {
+	vector<MetadataBlockInfo> result;
+	for (auto &block : blocks) {
+		MetadataBlockInfo block_info;
+		block_info.block_id = block.second.block_id;
+		block_info.total_blocks = MetadataManager::METADATA_BLOCK_COUNT;
+		for (auto free_block : block.second.free_blocks) {
+			block_info.free_list.push_back(free_block);
+		}
+		std::sort(block_info.free_list.begin(), block_info.free_list.end());
+		result.push_back(std::move(block_info));
+	}
+	std::sort(result.begin(), result.end(),
+	          [](const MetadataBlockInfo &a, const MetadataBlockInfo &b) { return a.block_id < b.block_id; });
+	return result;
+}
+
+block_id_t MetadataManager::GetNextBlockId() {
+	return block_manager.GetFreeBlockId();
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,89 @@
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+
+namespace duckdb {
+
+MetadataReader::MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
+                               optional_ptr<vector<MetaBlockPointer>> read_pointers_p, BlockReaderType type)
+    : manager(manager), type(type), next_pointer(FromDiskPointer(pointer)), has_next_block(true),
+      read_pointers(read_pointers_p), index(0), offset(0), next_offset(pointer.offset), capacity(0) {
+	if (read_pointers) {
+		D_ASSERT(read_pointers->empty());
+		read_pointers->push_back(pointer);
+	}
+}
+
+MetadataReader::MetadataReader(MetadataManager &manager, BlockPointer pointer)
+    : MetadataReader(manager, MetadataManager::FromBlockPointer(pointer)) {
+}
+
+MetadataPointer MetadataReader::FromDiskPointer(MetaBlockPointer pointer) {
+	if (type == BlockReaderType::EXISTING_BLOCKS) {
+		return manager.FromDiskPointer(pointer);
+	} else {
+		return manager.RegisterDiskPointer(pointer);
+	}
+}
+
+MetadataReader::~MetadataReader() {
+}
+
+void MetadataReader::ReadData(data_ptr_t buffer, idx_t read_size) {
+	while (offset + read_size > capacity) {
+		// cannot read entire entry from block
+		// first read what we can from this block
+		idx_t to_read = capacity - offset;
+		if (to_read > 0) {
+			memcpy(buffer, Ptr(), to_read);
+			read_size -= to_read;
+			buffer += to_read;
+			offset += read_size;
+		}
+		// then move to the next block
+		ReadNextBlock();
+	}
+	// we have enough left in this block to read from the buffer
+	memcpy(buffer, Ptr(), read_size);
+	offset += read_size;
+}
+
+MetaBlockPointer MetadataReader::GetMetaBlockPointer() {
+	return manager.GetDiskPointer(block.pointer, offset);
+}
+
+void MetadataReader::ReadNextBlock() {
+	if (!has_next_block) {
+		throw IOException("No more data remaining in MetadataReader");
+	}
+	block = manager.Pin(next_pointer);
+	index = next_pointer.index;
+
+	idx_t next_block = Load<idx_t>(BasePtr());
+	if (next_block == idx_t(-1)) {
+		has_next_block = false;
+	} else {
+		next_pointer = FromDiskPointer(MetaBlockPointer(next_block, 0));
+		MetaBlockPointer next_block_pointer(next_block, 0);
+		if (read_pointers) {
+			read_pointers->push_back(next_block_pointer);
+		}
+	}
+	if (next_offset < sizeof(block_id_t)) {
+		next_offset = sizeof(block_id_t);
+	}
+	if (next_offset > MetadataManager::METADATA_BLOCK_SIZE) {
+		throw InternalException("next_offset cannot be bigger than block size");
+	}
+	offset = next_offset;
+	next_offset = sizeof(block_id_t);
+	capacity = MetadataManager::METADATA_BLOCK_SIZE;
+}
+
+data_ptr_t MetadataReader::BasePtr() {
+	return block.handle.Ptr() + index * MetadataManager::METADATA_BLOCK_SIZE;
+}
+
+data_ptr_t MetadataReader::Ptr() {
+	return BasePtr() + offset;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,92 @@
+#include "duckdb/storage/metadata/metadata_writer.hpp"
+#include "duckdb/storage/block_manager.hpp"
+
+namespace duckdb {
+
+MetadataWriter::MetadataWriter(MetadataManager &manager, optional_ptr<vector<MetaBlockPointer>> written_pointers_p)
+    : manager(manager), written_pointers(written_pointers_p), capacity(0), offset(0) {
+	D_ASSERT(!written_pointers || written_pointers->empty());
+}
+
+MetadataWriter::~MetadataWriter() {
+	// If there's an exception during checkpoint, this can get destroyed without
+	// flushing the data...which is fine, because none of the unwritten data
+	// will be referenced.
+	//
+	// Otherwise, we should have explicitly flushed (and thereby nulled the block).
+	D_ASSERT(!block.handle.IsValid() || Exception::UncaughtException());
+}
+
+BlockPointer MetadataWriter::GetBlockPointer() {
+	return MetadataManager::ToBlockPointer(GetMetaBlockPointer());
+}
+
+MetaBlockPointer MetadataWriter::GetMetaBlockPointer() {
+	if (offset >= capacity) {
+		// at the end of the block - fetch the next block
+		NextBlock();
+		D_ASSERT(capacity > 0);
+	}
+	return manager.GetDiskPointer(block.pointer, offset);
+}
+
+MetadataHandle MetadataWriter::NextHandle() {
+	return manager.AllocateHandle();
+}
+
+void MetadataWriter::NextBlock() {
+	// now we need to get a new block id
+	auto new_handle = NextHandle();
+
+	// write the block id of the new block to the start of the current block
+	if (capacity > 0) {
+		auto disk_block = manager.GetDiskPointer(new_handle.pointer);
+		Store<idx_t>(disk_block.block_pointer, BasePtr());
+	}
+	// now update the block id of the block
+	block = std::move(new_handle);
+	current_pointer = block.pointer;
+	offset = sizeof(idx_t);
+	capacity = MetadataManager::METADATA_BLOCK_SIZE;
+	Store<idx_t>(-1, BasePtr());
+	if (written_pointers) {
+		written_pointers->push_back(manager.GetDiskPointer(current_pointer));
+	}
+}
+
+void MetadataWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
+	while (offset + write_size > capacity) {
+		// we need to make a new block
+		// first copy what we can
+		D_ASSERT(offset <= capacity);
+		idx_t copy_amount = capacity - offset;
+		if (copy_amount > 0) {
+			memcpy(Ptr(), buffer, copy_amount);
+			buffer += copy_amount;
+			offset += copy_amount;
+			write_size -= copy_amount;
+		}
+		// move forward to the next block
+		NextBlock();
+	}
+	memcpy(Ptr(), buffer, write_size);
+	offset += write_size;
+}
+
+void MetadataWriter::Flush() {
+	if (offset < capacity) {
+		// clear remaining bytes of block (if any)
+		memset(Ptr(), 0, capacity - offset);
+	}
+	block.handle.Destroy();
+}
+
+data_ptr_t MetadataWriter::BasePtr() {
+	return block.handle.Ptr() + current_pointer.index * MetadataManager::METADATA_BLOCK_SIZE;
+}
+
+data_ptr_t MetadataWriter::Ptr() {
+	return BasePtr() + offset;
+}
+
+} // namespace duckdb

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

@@ -2,6 +2,38 @@
 
 namespace duckdb {
 
+//===--------------------------------------------------------------------===//
+// PartialBlock
+//===--------------------------------------------------------------------===//
+
+PartialBlock::PartialBlock(PartialBlockState state, BlockManager &block_manager,
+                           const shared_ptr<BlockHandle> &block_handle)
+    : state(state), block_manager(block_manager), block_handle(block_handle) {
+}
+
+void PartialBlock::AddUninitializedRegion(idx_t start, idx_t end) {
+	uninitialized_regions.push_back({start, end});
+}
+
+void PartialBlock::FlushInternal(const idx_t free_space_left) {
+
+	// ensure that we do not leak any data
+	if (free_space_left > 0 || !uninitialized_regions.empty()) {
+		auto buffer_handle = block_manager.buffer_manager.Pin(block_handle);
+
+		// memset any uninitialized regions
+		for (auto &uninitialized : uninitialized_regions) {
+			memset(buffer_handle.Ptr() + uninitialized.start, 0, uninitialized.end - uninitialized.start);
+		}
+		// memset any free space at the end of the block to 0 prior to writing to disk
+		memset(buffer_handle.Ptr() + Storage::BLOCK_SIZE - free_space_left, 0, free_space_left);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// PartialBlockManager
+//===--------------------------------------------------------------------===//
+
 PartialBlockManager::PartialBlockManager(BlockManager &block_manager, CheckpointType checkpoint_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),
@@ -9,9 +41,7 @@ PartialBlockManager::PartialBlockManager(BlockManager &block_manager, Checkpoint
 }
 PartialBlockManager::~PartialBlockManager() {
 }
-//===--------------------------------------------------------------------===//
-// Partial Blocks
-//===--------------------------------------------------------------------===//
+
 PartialBlockAllocation PartialBlockManager::GetBlockAllocation(uint32_t segment_size) {
 	PartialBlockAllocation allocation;
 	allocation.block_manager = &block_manager;
@@ -47,7 +77,7 @@ void PartialBlockManager::AllocateBlock(PartialBlockState &state, uint32_t segme
 		state.block_id = INVALID_BLOCK;
 	}
 	state.block_size = Storage::BLOCK_SIZE;
-	state.offset_in_block = 0;
+	state.offset = 0;
 	state.block_use_count = 1;
 }
 
@@ -60,21 +90,22 @@ bool PartialBlockManager::GetPartialBlock(idx_t segment_size, unique_ptr<Partial
 	partial_block = std::move(entry->second);
 	partially_filled_blocks.erase(entry);
 
-	D_ASSERT(partial_block->state.offset_in_block > 0);
-	D_ASSERT(ValueIsAligned(partial_block->state.offset_in_block));
+	D_ASSERT(partial_block->state.offset > 0);
+	D_ASSERT(ValueIsAligned(partial_block->state.offset));
 	return true;
 }
 
 void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation &&allocation) {
 	auto &state = allocation.partial_block->state;
+	D_ASSERT(checkpoint_type != CheckpointType::FULL_CHECKPOINT || state.block_id >= 0);
 	if (state.block_use_count < max_use_count) {
-		auto unaligned_size = allocation.allocation_size + state.offset_in_block;
+		auto unaligned_size = allocation.allocation_size + state.offset;
 		auto new_size = AlignValue(unaligned_size);
 		if (new_size != unaligned_size) {
 			// register the uninitialized region so we can correctly initialize it before writing to disk
 			allocation.partial_block->AddUninitializedRegion(unaligned_size, new_size);
 		}
-		state.offset_in_block = new_size;
+		state.offset = new_size;
 		auto new_space_left = state.block_size - new_size;
 		// check if the block is STILL partially filled after adding the segment_size
 		if (new_space_left >= Storage::BLOCK_SIZE - max_partial_block_size) {
@@ -82,7 +113,7 @@ void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation &&allocati
 			partially_filled_blocks.insert(make_pair(new_space_left, std::move(allocation.partial_block)));
 		}
 	}
-	idx_t free_space = state.block_size - state.offset_in_block;
+	idx_t free_space = state.block_size - state.offset;
 	auto block_to_free = std::move(allocation.partial_block);
 	if (!block_to_free && partially_filled_blocks.size() > MAX_BLOCK_MAP_SIZE) {
 		// Free the page with the least space free.
@@ -98,10 +129,6 @@ void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation &&allocati
 	}
 }
 
-void PartialBlock::Merge(PartialBlock &other, idx_t offset, idx_t other_size) {
-	throw InternalException("PartialBlock::Merge not implemented for this block type");
-}
-
 void PartialBlockManager::Merge(PartialBlockManager &other) {
 	if (&other == this) {
 		throw InternalException("Cannot merge into itself");
@@ -117,10 +144,10 @@ void PartialBlockManager::Merge(PartialBlockManager &other) {
 			// we can merge this block into an existing block - merge them
 			// merge blocks
 			auto allocation = GetBlockAllocation(used_space);
-			allocation.partial_block->Merge(*e.second, allocation.state.offset_in_block, used_space);
+			allocation.partial_block->Merge(*e.second, allocation.state.offset, used_space);
 
 			// re-register the partial block
-			allocation.state.offset_in_block += used_space;
+			allocation.state.offset += used_space;
 			RegisterPartialBlock(std::move(allocation));
 		} else {
 			// we cannot merge this block - append it directly to the current block manager