duckdb 0.8.2-dev87.0 → 0.9.0

package/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 class DatabaseInstance;
 class ClientContext;
 class ColumnSegment;
-class MetaBlockReader;
+class MetadataReader;
 class SchemaCatalogEntry;
 class SequenceCatalogEntry;
 class TableCatalogEntry;
@@ -33,18 +33,20 @@ public:
 	//! The database
 	AttachedDatabase &db;
 
-	virtual MetaBlockWriter &GetMetaBlockWriter() = 0;
+	virtual MetadataManager &GetMetadataManager() = 0;
+	virtual MetadataWriter &GetMetadataWriter() = 0;
 	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) = 0;
 
 protected:
-	virtual void WriteSchema(SchemaCatalogEntry &schema);
-	virtual void WriteTable(TableCatalogEntry &table);
-	virtual void WriteView(ViewCatalogEntry &table);
-	virtual void WriteSequence(SequenceCatalogEntry &table);
-	virtual void WriteMacro(ScalarMacroCatalogEntry &table);
-	virtual void WriteTableMacro(TableMacroCatalogEntry &table);
-	virtual void WriteIndex(IndexCatalogEntry &index_catalog);
-	virtual void WriteType(TypeCatalogEntry &type);
+	virtual void WriteEntry(CatalogEntry &entry, Serializer &serializer);
+	virtual void WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer);
+	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer);
+	virtual void WriteView(ViewCatalogEntry &table, Serializer &serializer);
+	virtual void WriteSequence(SequenceCatalogEntry &table, Serializer &serializer);
+	virtual void WriteMacro(ScalarMacroCatalogEntry &table, Serializer &serializer);
+	virtual void WriteTableMacro(TableMacroCatalogEntry &table, Serializer &serializer);
+	virtual void WriteIndex(IndexCatalogEntry &index_catalog, Serializer &serializer);
+	virtual void WriteType(TypeCatalogEntry &type, Serializer &serializer);
 };
 
 class CheckpointReader {
@@ -58,17 +60,18 @@ protected:
 	Catalog &catalog;
 
 protected:
-	virtual void LoadCheckpoint(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadSchema(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadTable(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadView(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadSequence(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadMacro(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadTableMacro(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadIndex(ClientContext &context, MetaBlockReader &reader);
-	virtual void ReadType(ClientContext &context, MetaBlockReader &reader);
-
-	virtual void ReadTableData(ClientContext &context, MetaBlockReader &reader, BoundCreateTableInfo &bound_info);
+	virtual void LoadCheckpoint(ClientContext &context, MetadataReader &reader);
+	virtual void ReadEntry(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadSchema(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadTable(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadView(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadSequence(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadMacro(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadTableMacro(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadIndex(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadType(ClientContext &context, Deserializer &deserializer);
+
+	virtual void ReadTableData(ClientContext &context, Deserializer &deserializer, BoundCreateTableInfo &bound_info);
 };
 
 class SingleFileCheckpointReader final : public CheckpointReader {
@@ -78,6 +81,7 @@ public:
 	}
 
 	void LoadFromStorage();
+	MetadataManager &GetMetadataManager();
 
 	//! The database
 	SingleFileStorageManager &storage;
@@ -98,16 +102,17 @@ public:
 	//! connection is available because right now the checkpointing cannot be done online. (TODO)
 	void CreateCheckpoint();
 
-	virtual MetaBlockWriter &GetMetaBlockWriter() override;
+	virtual MetadataWriter &GetMetadataWriter() override;
+	virtual MetadataManager &GetMetadataManager() override;
 	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) override;
 
 	BlockManager &GetBlockManager();
 
 private:
 	//! The metadata writer is responsible for writing schema information
-	unique_ptr<MetaBlockWriter> metadata_writer;
+	unique_ptr<MetadataWriter> metadata_writer;
 	//! The table data writer is responsible for writing the DataPointers used by the table chunks
-	unique_ptr<MetaBlockWriter> table_metadata_writer;
+	unique_ptr<MetadataWriter> table_metadata_writer;
 	//! Because this is single-file storage, we can share partial blocks across
 	//! an entire checkpoint.
 	PartialBlockManager partial_block_manager;

package/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp

@@ -12,14 +12,7 @@
 
 namespace duckdb {
 
-enum class BitpackingMode : uint8_t {
-	AUTO,
-
-	CONSTANT,
-	CONSTANT_DELTA,
-	DELTA_FOR,
-	FOR
-};
+enum class BitpackingMode : uint8_t { INVALID, AUTO, CONSTANT, CONSTANT_DELTA, DELTA_FOR, FOR };
 
 BitpackingMode BitpackingModeFromString(const string &str);
 string BitpackingModeToString(const BitpackingMode &mode);

package/src/duckdb/src/include/duckdb/storage/data_pointer.hpp

@@ -17,8 +17,30 @@
 
 namespace duckdb {
 
+class Serializer;
+class Deserializer;
+
+struct ColumnSegmentState {
+	virtual ~ColumnSegmentState() {
+	}
+
+	virtual void Serialize(Serializer &serializer) const = 0;
+	static unique_ptr<ColumnSegmentState> Deserialize(Deserializer &deserializer);
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
 struct DataPointer {
-	DataPointer(BaseStatistics stats) : statistics(std::move(stats)) {
+	explicit DataPointer(BaseStatistics stats) : statistics(std::move(stats)) {
 	}
 
 	uint64_t row_start;
@@ -27,15 +49,20 @@ struct DataPointer {
 	CompressionType compression_type;
 	//! Type-specific statistics of the segment
 	BaseStatistics statistics;
+	//! Serialized segment state
+	unique_ptr<ColumnSegmentState> segment_state;
+
+	void Serialize(Serializer &serializer) const;
+	static DataPointer Deserialize(Deserializer &source);
 };
 
 struct RowGroupPointer {
 	uint64_t row_start;
 	uint64_t tuple_count;
 	//! The data pointers of the column segments stored in the row group
-	vector<BlockPointer> data_pointers;
-	//! The versions information of the row group (if any)
-	shared_ptr<VersionNode> versions;
+	vector<MetaBlockPointer> data_pointers;
+	//! Data pointers to the delete information of the row group (if any)
+	vector<MetaBlockPointer> deletes_pointers;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -51,7 +51,7 @@ public:
 	          const string &table, vector<ColumnDefinition> column_definitions_p,
 	          unique_ptr<PersistentTableData> data = nullptr);
 	//! Constructs a DataTable as a delta on an existing data table with a newly added column
-	DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value);
+	DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression &default_value);
 	//! Constructs a DataTable as a delta on an existing data table but with one column removed
 	DataTable(ClientContext &context, DataTable &parent, idx_t removed_column);
 	//! Constructs a DataTable as a delta on an existing data table but with one column changed type
@@ -125,7 +125,7 @@ public:
 	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
 	                  const vector<column_t> &column_path, DataChunk &updates);
 
-	//! Add an index to the DataTable. NOTE: for CREATE (UNIQUE) INDEX statements, we use the PhysicalCreateIndex
+	//! Add an index to the DataTable. NOTE: for CREATE (UNIQUE) INDEX statements, we use the PhysicalCreateARTIndex
 	//! operator. This function is only used during the WAL replay, and is a much less performant index creation
 	//! approach.
 	void WALAddIndex(ClientContext &context, unique_ptr<Index> index,
@@ -144,7 +144,7 @@ public:
 	//! Revert a set of appends made by the given AppendState, used to revert appends in the event of an error during
 	//! commit (e.g. because of an I/O exception)
 	void RevertAppend(idx_t start_row, idx_t count);
-	void RevertAppendInternal(idx_t start_row, idx_t count);
+	void RevertAppendInternal(idx_t start_row);
 
 	void ScanTableSegment(idx_t start_row, idx_t count, const std::function<void(DataChunk &chunk)> &function);
 
@@ -175,7 +175,7 @@ public:
 	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
 	//! Checkpoint the table to the specified table data writer
-	void Checkpoint(TableDataWriter &writer);
+	void Checkpoint(TableDataWriter &writer, Serializer &metadata_serializer);
 	void CommitDropTable();
 	void CommitDropColumn(idx_t index);
 

package/src/duckdb/src/include/duckdb/storage/database_size.hpp

@@ -21,4 +21,10 @@ struct DatabaseSize {
 	idx_t wal_size = 0;
 };
 
+struct MetadataBlockInfo {
+	block_id_t block_id;
+	idx_t total_blocks;
+	vector<idx_t> free_list;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp

@@ -29,7 +29,7 @@ public:
 	block_id_t GetFreeBlockId() override {
 		throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!");
 	}
-	bool IsRootBlock(block_id_t root) override {
+	bool IsRootBlock(MetaBlockPointer root) override {
 		throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!");
 	}
 	void MarkBlockAsFree(block_id_t block_id) override {
@@ -41,7 +41,7 @@ public:
 	void IncreaseBlockReferenceCount(block_id_t block_id) override {
 		throw InternalException("Cannot perform IO in in-memory database - IncreaseBlockReferenceCount!");
 	}
-	block_id_t GetMetaBlock() override {
+	idx_t GetMetaBlock() override {
 		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
 	}
 	void Read(Block &block) override {

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -14,7 +14,7 @@
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/constraint_conflict_info.hpp"
 
@@ -54,8 +54,6 @@ public:
 
 	//! Attached database instance
 	AttachedDatabase &db;
-	//! Buffer manager of the database instance
-	BufferManager &buffer_manager;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
@@ -85,6 +83,10 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	virtual void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) = 0;
 
+	//! Deletes all data from the index. The lock obtained from InitializeLock must be held
+	virtual void CommitDrop(IndexLock &index_lock) = 0;
+	//! Deletes all data from the index
+	void CommitDrop();
 	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
 	//! Obtains a lock and calls Delete while holding that lock
@@ -125,11 +127,11 @@ public:
 		return (constraint_type == IndexConstraintType::FOREIGN);
 	}
 
-	//! Serializes the index and returns the pair of block_id offset positions
-	virtual BlockPointer Serialize(MetaBlockWriter &writer);
-	//! Returns the serialized data pointer to the block and offset of the serialized index
-	BlockPointer GetSerializedDataPointer() const {
-		return serialized_data_pointer;
+	//! Serializes the index to disk
+	virtual BlockPointer Serialize(MetadataWriter &writer);
+	//! Returns the serialized root block pointer
+	BlockPointer GetRootBlockPointer() const {
+		return root_block_pointer;
 	}
 
 	//! Execute the index expressions on an input chunk
@@ -139,8 +141,8 @@ public:
 protected:
 	//! Lock used for any changes to the index
 	mutex lock;
-	//! Pointer to serialized index data
-	BlockPointer serialized_data_pointer;
+	//! Pointer to the index on disk
+	BlockPointer root_block_pointer;
 
 private:
 	//! Bound expressions used during expression execution

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp

@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/metadata/metadata_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/storage/block.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/common/set.hpp"
+#include "duckdb/storage/buffer/buffer_handle.hpp"
+
+namespace duckdb {
+class DatabaseInstance;
+struct MetadataBlockInfo;
+
+struct MetadataBlock {
+	shared_ptr<BlockHandle> block;
+	block_id_t block_id;
+	vector<uint8_t> free_blocks;
+
+	void Write(WriteStream &sink);
+	static MetadataBlock Read(ReadStream &source);
+
+	idx_t FreeBlocksToInteger();
+	void FreeBlocksFromInteger(idx_t blocks);
+};
+
+struct MetadataPointer {
+	idx_t block_index : 56;
+	uint8_t index : 8;
+};
+
+struct MetadataHandle {
+	MetadataPointer pointer;
+	BufferHandle handle;
+};
+
+class MetadataManager {
+public:
+	//! The size of metadata blocks
+	static constexpr const idx_t METADATA_BLOCK_SIZE = 4088;
+	//! The amount of metadata blocks per storage block
+	static constexpr const idx_t METADATA_BLOCK_COUNT = 64;
+
+public:
+	MetadataManager(BlockManager &block_manager, BufferManager &buffer_manager);
+	~MetadataManager();
+
+	MetadataHandle AllocateHandle();
+	MetadataHandle Pin(MetadataPointer pointer);
+
+	MetaBlockPointer GetDiskPointer(MetadataPointer pointer, uint32_t offset = 0);
+	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
+	MetadataPointer RegisterDiskPointer(MetaBlockPointer pointer);
+
+	static BlockPointer ToBlockPointer(MetaBlockPointer meta_pointer);
+	static MetaBlockPointer FromBlockPointer(BlockPointer block_pointer);
+
+	//! Flush all blocks to disk
+	void Flush();
+
+	void MarkBlocksAsModified();
+	void ClearModifiedBlocks(const vector<MetaBlockPointer> &pointers);
+
+	vector<MetadataBlockInfo> GetMetadataInfo() const;
+	idx_t BlockCount();
+
+	void Write(WriteStream &sink);
+	void Read(ReadStream &source);
+
+protected:
+	BlockManager &block_manager;
+	BufferManager &buffer_manager;
+	unordered_map<block_id_t, MetadataBlock> blocks;
+	unordered_map<block_id_t, idx_t> modified_blocks;
+
+protected:
+	block_id_t AllocateNewBlock();
+	block_id_t GetNextBlockId();
+
+	void AddBlock(MetadataBlock new_block, bool if_exists = false);
+	void AddAndRegisterBlock(MetadataBlock block);
+	void ConvertToTransient(MetadataBlock &block);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/metadata/metadata_reader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/read_stream.hpp"
+
+namespace duckdb {
+
+enum class BlockReaderType { EXISTING_BLOCKS, REGISTER_BLOCKS };
+
+class MetadataReader : public ReadStream {
+public:
+	MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
+	               optional_ptr<vector<MetaBlockPointer>> read_pointers = nullptr,
+	               BlockReaderType type = BlockReaderType::EXISTING_BLOCKS);
+	MetadataReader(MetadataManager &manager, BlockPointer pointer);
+	~MetadataReader() override;
+
+public:
+	//! Read content of size read_size into the buffer
+	void ReadData(data_ptr_t buffer, idx_t read_size) override;
+
+	MetaBlockPointer GetMetaBlockPointer();
+
+	MetadataManager &GetMetadataManager() {
+		return manager;
+	}
+
+private:
+	data_ptr_t BasePtr();
+	data_ptr_t Ptr();
+
+	void ReadNextBlock();
+
+	MetadataPointer FromDiskPointer(MetaBlockPointer pointer);
+
+private:
+	MetadataManager &manager;
+	BlockReaderType type;
+	MetadataHandle block;
+	MetadataPointer next_pointer;
+	bool has_next_block;
+	optional_ptr<vector<MetaBlockPointer>> read_pointers;
+	idx_t index;
+	idx_t offset;
+	idx_t next_offset;
+	idx_t capacity;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/metadata/metadata_writer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
+
+namespace duckdb {
+
+class MetadataWriter : public WriteStream {
+public:
+	explicit MetadataWriter(MetadataManager &manager,
+	                        optional_ptr<vector<MetaBlockPointer>> written_pointers = nullptr);
+	MetadataWriter(const MetadataWriter &) = delete;
+	MetadataWriter &operator=(const MetadataWriter &) = delete;
+	~MetadataWriter() override;
+
+public:
+	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
+	void Flush();
+
+	BlockPointer GetBlockPointer();
+	MetaBlockPointer GetMetaBlockPointer();
+	MetadataManager &GetManager() {
+		return manager;
+	}
+
+protected:
+	virtual MetadataHandle NextHandle();
+
+private:
+	data_ptr_t BasePtr();
+	data_ptr_t Ptr();
+
+	void NextBlock();
+
+private:
+	MetadataManager &manager;
+	MetadataHandle block;
+	MetadataPointer current_pointer;
+	optional_ptr<vector<MetaBlockPointer>> written_pointers;
+	idx_t capacity;
+	idx_t offset;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/object_cache.hpp

@@ -47,11 +47,33 @@ public:
 		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
 	}
 
+	template <class T, class... Args>
+	shared_ptr<T> GetOrCreate(const string &key, Args &&...args) {
+		lock_guard<mutex> glock(lock);
+
+		auto entry = cache.find(key);
+		if (entry == cache.end()) {
+			auto value = make_shared<T>(args...);
+			cache[key] = value;
+			return value;
+		}
+		auto object = entry->second;
+		if (!object || object->GetObjectType() != T::ObjectType()) {
+			return nullptr;
+		}
+		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
+	}
+
 	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
 		lock_guard<mutex> glock(lock);
 		cache[key] = std::move(value);
 	}
 
+	void Delete(const string &key) {
+		lock_guard<mutex> glock(lock);
+		cache.erase(key);
+	}
+
 	DUCKDB_API static ObjectCache &GetObjectCache(ClientContext &context);
 	DUCKDB_API static bool ObjectCacheEnabled(ClientContext &context);
 

package/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp

@@ -11,44 +11,60 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/storage/data_pointer.hpp"
 
 namespace duckdb {
 class DatabaseInstance;
 class ClientContext;
 class ColumnSegment;
-class MetaBlockReader;
+class MetadataReader;
 class SchemaCatalogEntry;
 class SequenceCatalogEntry;
 class TableCatalogEntry;
 class ViewCatalogEntry;
 class TypeCatalogEntry;
 
+//! Regions that require zero-initialization to avoid leaking memory
+struct UninitializedRegion {
+	idx_t start;
+	idx_t end;
+};
+
+//! The current state of a partial block
 struct PartialBlockState {
+	//! The block id of the partial block
 	block_id_t block_id;
-	//! How big is the block we're writing to. (Total bytes to assign).
+	//! The total bytes that we can assign to this block
 	uint32_t block_size;
-	//! How many bytes of the allocation are used. (offset_in_block of next allocation)
-	uint32_t offset_in_block;
-	//! How many times has the block been used?
+	//! Next allocation offset, and also the current allocation size
+	uint32_t offset;
+	//! The number of times that this block has been used for partial allocations
 	uint32_t block_use_count;
 };
 
 struct PartialBlock {
-	explicit PartialBlock(PartialBlockState state) : state(std::move(state)) {
-	}
+	PartialBlock(PartialBlockState state, BlockManager &block_manager, const shared_ptr<BlockHandle> &block_handle);
 	virtual ~PartialBlock() {
 	}
 
+	//! The current state of a partial block
 	PartialBlockState state;
+	//! All uninitialized regions on this block, we need to zero-initialize them when flushing
+	vector<UninitializedRegion> uninitialized_regions;
+	//! The block manager of the partial block manager
+	BlockManager &block_manager;
+	//! The block handle of the underlying block that this partial block writes to
+	shared_ptr<BlockHandle> block_handle;
 
 public:
-	virtual void AddUninitializedRegion(idx_t start, idx_t end) = 0;
-	virtual void Flush(idx_t free_space_left) = 0;
-	virtual void Clear() {
-	}
-	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size);
+	//! Add regions that need zero-initialization to avoid leaking memory
+	void AddUninitializedRegion(const idx_t start, const idx_t end);
+	//! Flush the block to disk and zero-initialize any free space and uninitialized regions
+	virtual void Flush(const idx_t free_space_left) = 0;
+	void FlushInternal(const idx_t free_space_left);
+	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size) = 0;
+	virtual void Clear() = 0;
 
 public:
 	template <class TARGET>
@@ -59,13 +75,13 @@ public:
 };
 
 struct PartialBlockAllocation {
-	// BlockManager owning the block_id
+	//! The BlockManager owning the block_id
 	BlockManager *block_manager {nullptr};
-	//! How many bytes assigned to the caller?
+	//! The number of assigned bytes to the caller
 	uint32_t allocation_size;
-	//! State of assigned block.
+	//! The current state of the partial block
 	PartialBlockState state;
-	//! Arbitrary state related to partial block storage.
+	//! Arbitrary state related to the partial block storage
 	unique_ptr<PartialBlock> partial_block;
 };
 
@@ -76,12 +92,12 @@ enum class CheckpointType { FULL_CHECKPOINT, APPEND_TO_TABLE };
 //! In any case, they must share a block manager.
 class PartialBlockManager {
 public:
-	// 20% free / 80% utilization
+	//! 20% free / 80% utilization
 	static constexpr const idx_t DEFAULT_MAX_PARTIAL_BLOCK_SIZE = Storage::BLOCK_SIZE / 5 * 4;
-	// Max number of shared references to a block. No effective limit by default.
+	//! Max number of shared references to a block. No effective limit by default.
 	static constexpr const idx_t DEFAULT_MAX_USE_COUNT = 1u << 20;
-	// No point letting map size grow unbounded. We'll drop blocks with the
-	// least free space first.
+	//! No point letting map size grow unbounded. We'll drop blocks with the
+	//! least free space first.
 	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
 
 public: