duckdb 0.8.2-dev4203.0 → 0.8.2-dev4376.0

package/src/duckdb/src/include/duckdb/transaction/commit_state.hpp

@@ -23,7 +23,7 @@ struct UpdateInfo;
 
 class CommitState {
 public:
-	explicit CommitState(ClientContext &context, transaction_t commit_id, optional_ptr<WriteAheadLog> log = nullptr);
+	explicit CommitState(transaction_t commit_id, optional_ptr<WriteAheadLog> log = nullptr);
 
 	optional_ptr<WriteAheadLog> log;
 	transaction_t commit_id;
@@ -35,9 +35,6 @@ public:
 	unique_ptr<DataChunk> delete_chunk;
 	unique_ptr<DataChunk> update_chunk;
 
-private:
-	ClientContext &context;
-
 public:
 	template <bool HAS_LOG>
 	void CommitEntry(UndoFlags type, data_ptr_t data);
@@ -49,8 +46,6 @@ private:
 	void WriteCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data);
 	void WriteDelete(DeleteInfo &info);
 	void WriteUpdate(UpdateInfo &info);
-
-	void AppendRowId(row_t rowid);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/transaction/delete_info.hpp

@@ -11,12 +11,13 @@
 #include "duckdb/common/constants.hpp"
 
 namespace duckdb {
-class ChunkVectorInfo;
 class DataTable;
+class RowVersionManager;
 
 struct DeleteInfo {
 	DataTable *table;
-	ChunkVectorInfo *vinfo;
+	RowVersionManager *version_info;
+	idx_t vector_idx;
 	idx_t count;
 	idx_t base_row;
 	row_t rows[1];

package/src/duckdb/src/include/duckdb/transaction/duck_transaction.hpp

@@ -11,12 +11,13 @@
 #include "duckdb/transaction/transaction.hpp"
 
 namespace duckdb {
+class RowVersionManager;
 
 class DuckTransaction : public Transaction {
 public:
 	DuckTransaction(TransactionManager &manager, ClientContext &context, transaction_t start_time,
 	                transaction_t transaction_id);
-	~DuckTransaction();
+	~DuckTransaction() override;
 
 	//! The start timestamp of this transaction
 	transaction_t start_time;
@@ -49,7 +50,8 @@ public:
 
 	bool ChangesMade();
 
-	void PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row);
+	void PushDelete(DataTable &table, RowVersionManager &info, idx_t vector_idx, row_t rows[], idx_t count,
+	                idx_t base_row);
 	void PushAppend(DataTable &table, idx_t row_start, idx_t row_count);
 	UpdateInfo *CreateUpdateInfo(idx_t type_size, idx_t entries);
 

package/src/duckdb/src/include/duckdb/transaction/local_storage.hpp

@@ -88,7 +88,7 @@ private:
 class LocalStorage {
 public:
 	// Threshold to merge row groups instead of appending
-	static constexpr const idx_t MERGE_THRESHOLD = RowGroup::ROW_GROUP_SIZE;
+	static constexpr const idx_t MERGE_THRESHOLD = Storage::ROW_GROUP_SIZE;
 
 public:
 	struct CommitState {

package/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp

@@ -48,7 +48,6 @@ public:
 	void Rollback() noexcept;
 
 private:
-	ClientContext &context;
 	ArenaAllocator allocator;
 
 private:

package/src/duckdb/src/main/relation.cpp

@@ -47,6 +47,11 @@ shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
 	return Project(expressions, aliases);
 }
 
+shared_ptr<Relation> Relation::Project(vector<unique_ptr<ParsedExpression>> expressions,
+                                       const vector<string> &aliases) {
+	return make_shared<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
+}
+
 static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
                                                                        const vector<string> &expressions) {
 	if (expressions.empty()) {
@@ -73,7 +78,11 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
-	return make_shared<FilterRelation>(shared_from_this(), std::move(expression_list[0]));
+	return Filter(std::move(expression_list[0]));
+}
+
+shared_ptr<Relation> Relation::Filter(unique_ptr<ParsedExpression> expression) {
+	return make_shared<FilterRelation>(shared_from_this(), std::move(expression));
 }
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
@@ -95,6 +104,10 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
 	auto order_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
+	return Order(std::move(order_list));
+}
+
+shared_ptr<Relation> Relation::Order(vector<OrderByNode> order_list) {
 	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
 }
 
@@ -110,7 +123,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 		}
 		order_list.push_back(std::move(inner_list[0]));
 	}
-	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
+	return Order(std::move(order_list));
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type,

package/src/duckdb/src/main/settings/settings.cpp

@@ -726,17 +726,12 @@ Value ForceCompressionSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void ForceBitpackingModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
 	auto mode_str = StringUtil::Lower(input.ToString());
-	if (mode_str == "none") {
-		config.options.force_bitpacking_mode = BitpackingMode::AUTO;
-	} else {
-		auto mode = BitpackingModeFromString(mode_str);
-		if (mode == BitpackingMode::AUTO) {
-			throw ParserException(
-			    "Unrecognized option for force_bitpacking_mode, expected none, constant, constant_delta, "
-			    "delta_for, or for");
-		}
-		config.options.force_bitpacking_mode = mode;
+	auto mode = BitpackingModeFromString(mode_str);
+	if (mode == BitpackingMode::INVALID) {
+		throw ParserException("Unrecognized option for force_bitpacking_mode, expected none, constant, constant_delta, "
+		                      "delta_for, or for");
 	}
+	config.options.force_bitpacking_mode = mode;
 }
 
 void ForceBitpackingModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {

package/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp

@@ -22,6 +22,20 @@ static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const B
 }
 
 static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatistics &input, const LogicalType &target) {
+	//	Downcasting timestamps to times is not a truncation operation
+	switch (target.id()) {
+	case LogicalTypeId::TIME:
+		switch (input.GetType().id()) {
+		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return nullptr;
+		default:
+			break;
+		}
+	default:
+		break;
+	}
+
 	switch (target.InternalType()) {
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -66,7 +66,6 @@ void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, Da
 		row_group_serializer.End();
 	}
 
-	// TODO: Serialize this:
 	auto index_pointers = info->indexes.SerializeIndexes(table_data_writer);
 
 	// Now begin the metadata as a unit

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -23,8 +23,7 @@ static constexpr const idx_t BITPACKING_METADATA_GROUP_SIZE = STANDARD_VECTOR_SI
 
 BitpackingMode BitpackingModeFromString(const string &str) {
 	auto mode = StringUtil::Lower(str);
-
-	if (mode == "auto") {
+	if (mode == "auto" || mode == "none") {
 		return BitpackingMode::AUTO;
 	} else if (mode == "constant") {
 		return BitpackingMode::CONSTANT;
@@ -35,21 +34,21 @@ BitpackingMode BitpackingModeFromString(const string &str) {
 	} else if (mode == "for") {
 		return BitpackingMode::FOR;
 	} else {
-		return BitpackingMode::AUTO;
+		return BitpackingMode::INVALID;
 	}
 }
 
 string BitpackingModeToString(const BitpackingMode &mode) {
 	switch (mode) {
-	case (BitpackingMode::AUTO):
+	case BitpackingMode::AUTO:
 		return "auto";
-	case (BitpackingMode::CONSTANT):
+	case BitpackingMode::CONSTANT:
 		return "constant";
-	case (BitpackingMode::CONSTANT_DELTA):
+	case BitpackingMode::CONSTANT_DELTA:
 		return "constant_delta";
-	case (BitpackingMode::DELTA_FOR):
+	case BitpackingMode::DELTA_FOR:
 		return "delta_for";
-	case (BitpackingMode::FOR):
+	case BitpackingMode::FOR:
 		return "for";
 	default:
 		throw NotImplementedException("Unknown bitpacking mode: " + to_string((uint8_t)mode) + "\n");
@@ -161,7 +160,7 @@ public:
 		// Don't delta encoding 1 value makes no sense
 		if (compression_buffer_idx < 2) {
 			return;
-		};
+		}
 
 		// TODO: handle NULLS here?
 		// Currently we cannot handle nulls because we would need an additional step of patching for this.
@@ -686,48 +685,57 @@ public:
 	}
 
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		while (skip_count > 0) {
-			if (current_group_offset + skip_count < BITPACKING_METADATA_GROUP_SIZE) {
-				// Skipping Delta FOR requires a bit of decoding to figure out the new delta
-				if (current_group.mode == BitpackingMode::DELTA_FOR) {
-					// if current_group_offset points into the middle of a
-					// BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE, we need to scan a few
-					// values before current_group_offset to align with the algorithm groups
-					idx_t extra_count = current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-					// Calculate total offset and count to bitunpack
-					idx_t base_decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(skip_count);
-					idx_t decompress_count = base_decompress_count + extra_count;
-					idx_t decompress_offset = current_group_offset - extra_count;
-					bool skip_sign_extension = true;
-
-					BitpackingPrimitives::UnPackBuffer<T>(data_ptr_cast(decompression_buffer),
-					                                      current_group_ptr + decompress_offset, decompress_count,
-					                                      current_width, skip_sign_extension);
-
-					ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(decompression_buffer + extra_count),
-					                           current_frame_of_reference, skip_count);
-					DeltaDecode<T_S>(reinterpret_cast<T_S *>(decompression_buffer + extra_count),
-					                 static_cast<T_S>(current_delta_offset), skip_count);
-					current_delta_offset = decompression_buffer[extra_count + skip_count - 1];
-
-					current_group_offset += skip_count;
-				} else {
-					current_group_offset += skip_count;
-				}
-				break;
-			} else {
-				auto left_in_this_group = BITPACKING_METADATA_GROUP_SIZE - current_group_offset;
-				auto number_of_groups_to_skip = (skip_count - left_in_this_group) / BITPACKING_METADATA_GROUP_SIZE;
-
-				current_group_offset = 0;
-				bitpacking_metadata_ptr -= number_of_groups_to_skip * sizeof(bitpacking_metadata_encoded_t);
+		bool skip_sign_extend = true;
 
+		idx_t skipped = 0;
+		while (skipped < skip_count) {
+			// Exhausted this metadata group, move pointers to next group and load metadata for next group.
+			if (current_group_offset >= BITPACKING_METADATA_GROUP_SIZE) {
 				LoadNextGroup();
+			}
 
-				skip_count -= left_in_this_group;
-				skip_count -= number_of_groups_to_skip * BITPACKING_METADATA_GROUP_SIZE;
+			idx_t offset_in_compression_group =
+			    current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+
+			if (current_group.mode == BitpackingMode::CONSTANT) {
+				idx_t remaining = skip_count - skipped;
+				idx_t to_skip = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - current_group_offset);
+				skipped += to_skip;
+				current_group_offset += to_skip;
+				continue;
+			}
+			if (current_group.mode == BitpackingMode::CONSTANT_DELTA) {
+				idx_t remaining = skip_count - skipped;
+				idx_t to_skip = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - current_group_offset);
+				skipped += to_skip;
+				current_group_offset += to_skip;
+				continue;
+			}
+			D_ASSERT(current_group.mode == BitpackingMode::FOR || current_group.mode == BitpackingMode::DELTA_FOR);
+
+			idx_t to_skip =
+			    MinValue<idx_t>(skip_count - skipped,
+			                    BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - offset_in_compression_group);
+			// Calculate start of compression algorithm group
+			if (current_group.mode == BitpackingMode::DELTA_FOR) {
+				data_ptr_t current_position_ptr = current_group_ptr + current_group_offset * current_width / 8;
+				data_ptr_t decompression_group_start_pointer =
+				    current_position_ptr - offset_in_compression_group * current_width / 8;
+
+				BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(decompression_buffer),
+				                                     decompression_group_start_pointer, current_width,
+				                                     skip_sign_extend);
+
+				T *decompression_ptr = decompression_buffer + offset_in_compression_group;
+				ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(decompression_ptr),
+				                           static_cast<T_S>(current_frame_of_reference), to_skip);
+				DeltaDecode<T_S>(reinterpret_cast<T_S *>(decompression_ptr), static_cast<T_S>(current_delta_offset),
+				                 to_skip);
+				current_delta_offset = decompression_ptr[to_skip - 1];
 			}
+
+			skipped += to_skip;
+			current_group_offset += to_skip;
 		}
 	}
 
@@ -757,7 +765,6 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 	bool skip_sign_extend = true;
 
 	idx_t scanned = 0;
-
 	while (scanned < scan_count) {
 		// Exhausted this metadata group, move pointers to next group and load metadata for next group.
 		if (scan_state.current_group_offset >= BITPACKING_METADATA_GROUP_SIZE) {

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

@@ -208,7 +208,7 @@ void DataTable::InitializeScanWithOffset(TableScanState &state, const vector<col
 }
 
 idx_t DataTable::MaxThreads(ClientContext &context) {
-	idx_t parallel_scan_vector_count = RowGroup::ROW_GROUP_VECTOR_COUNT;
+	idx_t parallel_scan_vector_count = Storage::ROW_GROUP_VECTOR_COUNT;
 	if (ClientConfig::GetConfig(context).verify_parallelism) {
 		parallel_scan_vector_count = 1;
 	}

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

@@ -102,7 +102,7 @@ void LocalTableStorage::WriteNewRowGroup() {
 }
 
 void LocalTableStorage::FlushBlocks() {
-	if (!merged_storage && row_groups->GetTotalRows() > RowGroup::ROW_GROUP_SIZE) {
+	if (!merged_storage && row_groups->GetTotalRows() > Storage::ROW_GROUP_SIZE) {
 		optimistic_writer.WriteLastRowGroup(*row_groups);
 	}
 	optimistic_writer.FinalFlush();

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

@@ -34,6 +34,12 @@ MetadataHandle MetadataManager::AllocateHandle() {
 	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
@@ -54,6 +60,23 @@ MetadataHandle MetadataManager::Pin(MetadataPointer pointer) {
 	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();
 
@@ -91,11 +114,11 @@ MetaBlockPointer MetadataManager::GetDiskPointer(MetadataPointer pointer, uint32
 	return MetaBlockPointer(block_pointer, offset);
 }
 
-block_id_t MetaBlockPointer::GetBlockId() {
+block_id_t MetaBlockPointer::GetBlockId() const {
 	return block_id_t(block_pointer & ~(idx_t(0xFF) << 56ULL));
 }
 
-uint32_t MetaBlockPointer::GetBlockIndex() {
+uint32_t MetaBlockPointer::GetBlockIndex() const {
 	return block_pointer >> 56ULL;
 }
 
@@ -262,6 +285,22 @@ void MetadataManager::MarkBlocksAsModified() {
 	}
 }
 
+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);
+	}
+}
+
 block_id_t MetadataManager::GetNextBlockId() {
 	return block_manager.GetFreeBlockId();
 }

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

@@ -2,9 +2,14 @@
 
 namespace duckdb {
 
-MetadataReader::MetadataReader(MetadataManager &manager, MetaBlockPointer pointer, BlockReaderType type)
-    : manager(manager), type(type), next_pointer(FromDiskPointer(pointer)), has_next_block(true), index(0), offset(0),
-      next_offset(pointer.offset), capacity(0) {
+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)
@@ -57,6 +62,10 @@ void MetadataReader::ReadNextBlock() {
 		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);

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

@@ -3,7 +3,9 @@
 
 namespace duckdb {
 
-MetadataWriter::MetadataWriter(MetadataManager &manager) : manager(manager), capacity(0), offset(0) {
+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() {
@@ -38,7 +40,8 @@ void MetadataWriter::NextBlock() {
 
 	// write the block id of the new block to the start of the current block
 	if (capacity > 0) {
-		Store<idx_t>(manager.GetDiskPointer(new_handle.pointer).block_pointer, BasePtr());
+		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);
@@ -46,6 +49,9 @@ void MetadataWriter::NextBlock() {
 	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) {

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

package/src/duckdb/src/storage/single_file_block_manager.cpp

@@ -240,8 +240,7 @@ void SingleFileBlockManager::LoadFreeList() {
 		// no free list
 		return;
 	}
-
-	MetadataReader reader(GetMetadataManager(), free_pointer, BlockReaderType::REGISTER_BLOCKS);
+	MetadataReader reader(GetMetadataManager(), free_pointer, nullptr, BlockReaderType::REGISTER_BLOCKS);
 	auto free_list_count = reader.Read<uint64_t>();
 	free_list.clear();
 	for (idx_t i = 0; i < free_list_count; i++) {

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 59;
+const uint64_t VERSION_NUMBER = 60;
 
 struct StorageVersionInfo {
 	const char *version_name;