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

package/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp

@@ -8,36 +8,61 @@
 
 #pragma once
 
+#include "duckdb/storage/partial_block_manager.hpp"
 #include "duckdb/common/typedefs.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
+#include "duckdb/storage/block_manager.hpp"
 
 namespace duckdb {
 
 class FixedSizeAllocator;
 class MetadataWriter;
 
+struct PartialBlockForIndex : public PartialBlock {
+public:
+	PartialBlockForIndex(PartialBlockState state, BlockManager &block_manager,
+	                     const shared_ptr<BlockHandle> &block_handle);
+	~PartialBlockForIndex() override {};
+
+public:
+	void Flush(const idx_t free_space_left) override;
+	void Clear() override;
+	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
+};
+
 //! A fixed-size buffer holds fixed-size segments of data. It lazily deserializes a buffer, if on-disk and not
 //! yet in memory, and it only serializes dirty and non-written buffers to disk during
 //! serialization.
 class FixedSizeBuffer {
+public:
+	//! Constants for fast offset calculations in the bitmask
+	static constexpr idx_t BASE[] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1};
+	static constexpr uint8_t SHIFT[] = {32, 16, 8, 4, 2, 1};
+
 public:
 	//! Constructor for a new in-memory buffer
 	explicit FixedSizeBuffer(BlockManager &block_manager);
 	//! Constructor for deserializing buffer metadata from disk
-	FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const block_id_t &block_id);
+	FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
+	                const BlockPointer &block_pointer);
 
 	//! Block manager of the database instance
 	BlockManager &block_manager;
 
 	//! The number of allocated segments
 	idx_t segment_count;
+	//! The size of allocated memory in this buffer (necessary for copying while pinning)
+	idx_t allocation_size;
 
 	//! True: the in-memory buffer is no longer consistent with a (possibly existing) copy on disk
 	bool dirty;
 	//! True: can be vacuumed after the vacuum operation
 	bool vacuum;
 
+	//! Partial block id and offset
+	BlockPointer block_pointer;
+
 public:
 	//! Returns true, if the buffer is in-memory
 	inline bool InMemory() const {
@@ -45,12 +70,7 @@ public:
 	}
 	//! Returns true, if the block is on-disk
 	inline bool OnDisk() const {
-		return (block_handle != nullptr) && (block_handle->BlockId() < MAXIMUM_BLOCK);
-	}
-	//! Returns the block ID
-	inline block_id_t BlockId() const {
-		D_ASSERT(OnDisk());
-		return block_handle->BlockId();
+		return block_pointer.IsValid();
 	}
 	//! Returns a pointer to the buffer in memory, and calls Deserialize, if the buffer is not in memory
 	inline data_ptr_t Get(const bool dirty_p = true) {
@@ -65,15 +85,25 @@ public:
 	//! Destroys the in-memory buffer and the on-disk block
 	void Destroy();
 	//! Serializes a buffer (if dirty or not on disk)
-	void Serialize();
+	void Serialize(PartialBlockManager &partial_block_manager, const idx_t available_segments, const idx_t segment_size,
+	               const idx_t bitmask_offset);
 	//! Pin a buffer (if not in-memory)
 	void Pin();
+	//! Returns the first free offset in a bitmask
+	uint32_t GetOffset(const idx_t bitmask_count);
 
 private:
 	//! The buffer handle of the in-memory buffer
 	BufferHandle buffer_handle;
 	//! The block handle of the on-disk buffer
 	shared_ptr<BlockHandle> block_handle;
+
+private:
+	//! Returns the maximum non-free offset in a bitmask
+	uint32_t GetMaxOffset(const idx_t available_segments_per_buffer);
+	//! Sets all uninitialized regions of a buffer in the respective partial block allocation
+	void SetUninitializedRegions(PartialBlockForIndex &p_block_for_index, const idx_t segment_size, const idx_t offset,
+	                             const idx_t bitmask_offset);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -67,6 +67,9 @@ struct ArrowScanLocalState : public LocalTableFunctionState {
 
 	unique_ptr<ArrowArrayStreamWrapper> stream;
 	shared_ptr<ArrowArrayWrapper> chunk;
+	// This vector hold the Arrow Vectors owned by DuckDB to allow for zero-copy
+	// Note that only DuckDB can release these vectors
+	unordered_map<idx_t, shared_ptr<ArrowArrayWrapper>> arrow_owned_data;
 	idx_t chunk_offset = 0;
 	idx_t batch_index = 0;
 	vector<column_t> column_ids;

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -19,8 +19,11 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
-
-#include <memory>
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/result_modifier.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/helper.hpp"
 
 namespace duckdb {
 struct BoundStatement;
@@ -81,9 +84,12 @@ public:
 	DUCKDB_API shared_ptr<Relation> Project(const string &select_list, const vector<string> &aliases);
 	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions);
 	DUCKDB_API shared_ptr<Relation> Project(const vector<string> &expressions, const vector<string> &aliases);
+	DUCKDB_API shared_ptr<Relation> Project(vector<unique_ptr<ParsedExpression>> expressions,
+	                                        const vector<string> &aliases);
 
 	// FILTER
 	DUCKDB_API shared_ptr<Relation> Filter(const string &expression);
+	DUCKDB_API shared_ptr<Relation> Filter(unique_ptr<ParsedExpression> expression);
 	DUCKDB_API shared_ptr<Relation> Filter(const vector<string> &expressions);
 
 	// LIMIT
@@ -92,6 +98,7 @@ public:
 	// ORDER
 	DUCKDB_API shared_ptr<Relation> Order(const string &expression);
 	DUCKDB_API shared_ptr<Relation> Order(const vector<string> &expressions);
+	DUCKDB_API shared_ptr<Relation> Order(vector<OrderByNode> expressions);
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,

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

@@ -52,11 +52,11 @@ struct MetaBlockPointer {
 	idx_t block_pointer;
 	uint32_t offset;
 
-	bool IsValid() {
+	bool IsValid() const {
 		return block_pointer != DConstants::INVALID_INDEX;
 	}
-	block_id_t GetBlockId();
-	uint32_t GetBlockIndex();
+	block_id_t GetBlockId() const;
+	uint32_t GetBlockIndex() const;
 
 	void Serialize(Serializer &serializer) const;
 	static MetaBlockPointer Deserialize(Deserializer &source);

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

@@ -40,8 +40,8 @@ struct RowGroupPointer {
 	uint64_t tuple_count;
 	//! The data pointers of the column segments stored in the row group
 	vector<MetaBlockPointer> data_pointers;
-	//! The versions information of the row group (if any)
-	shared_ptr<VersionNode> versions;
+	//! 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/metadata/metadata_manager.hpp

@@ -64,6 +64,7 @@ public:
 	void Flush();
 
 	void MarkBlocksAsModified();
+	void ClearModifiedBlocks(const vector<MetaBlockPointer> &pointers);
 
 	idx_t BlockCount();
 
@@ -82,6 +83,7 @@ protected:
 
 	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

@@ -18,6 +18,7 @@ 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;
@@ -46,6 +47,7 @@ private:
 	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;

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

@@ -15,10 +15,10 @@ 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;
-
-	explicit MetadataWriter(MetadataManager &manager);
 	~MetadataWriter() override;
 
 public:
@@ -27,6 +27,9 @@ public:
 
 	BlockPointer GetBlockPointer();
 	MetaBlockPointer GetMetaBlockPointer();
+	MetadataManager &GetManager() {
+		return manager;
+	}
 
 protected:
 	virtual MetadataHandle NextHandle();
@@ -41,6 +44,7 @@ private:
 	MetadataManager &manager;
 	MetadataHandle block;
 	MetadataPointer current_pointer;
+	optional_ptr<vector<MetaBlockPointer>> written_pointers;
 	idx_t capacity;
 	idx_t offset;
 };

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

@@ -25,30 +25,46 @@ 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:

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

@@ -23,6 +23,25 @@ struct FileHandle;
 #error Row group size should be cleanly divisible by vector size
 #endif
 
+struct Storage {
+	//! The size of a hard disk sector, only really needed for Direct IO
+	constexpr static int SECTOR_SIZE = 4096;
+	//! Block header size for blocks written to the storage
+	constexpr static int BLOCK_HEADER_SIZE = sizeof(uint64_t);
+	// Size of a memory slot managed by the StorageManager. This is the quantum of allocation for Blocks on DuckDB. We
+	// default to 256KB. (1 << 18)
+	constexpr static int BLOCK_ALLOC_SIZE = 262144;
+	//! The actual memory space that is available within the blocks
+	constexpr static int BLOCK_SIZE = BLOCK_ALLOC_SIZE - BLOCK_HEADER_SIZE;
+	//! The size of the headers. This should be small and written more or less atomically by the hard disk. We default
+	//! to the page size, which is 4KB. (1 << 12)
+	constexpr static int FILE_HEADER_SIZE = 4096;
+	//! The number of rows per row group (must be a multiple of the vector size)
+	constexpr static const idx_t ROW_GROUP_SIZE = STANDARD_ROW_GROUPS_SIZE;
+	//! The number of vectors per row group
+	constexpr static const idx_t ROW_GROUP_VECTOR_COUNT = ROW_GROUP_SIZE / STANDARD_VECTOR_SIZE;
+};
+
 //! The version number of the database storage format
 extern const uint64_t VERSION_NUMBER;
 

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -46,8 +46,10 @@ public:
 	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
 	virtual idx_t GetCommittedDeletedCount(idx_t max_count) = 0;
 
-	virtual void Serialize(Serializer &serializer) const = 0;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
+	virtual bool HasDeletes() const = 0;
+
+	virtual void Write(WriteStream &writer) const;
+	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
 
 public:
 	template <class TARGET>
@@ -74,8 +76,8 @@ public:
 public:
 	explicit ChunkConstantInfo(idx_t start);
 
-	atomic<transaction_t> insert_id;
-	atomic<transaction_t> delete_id;
+	transaction_t insert_id;
+	transaction_t delete_id;
 
 public:
 	idx_t GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) override;
@@ -85,8 +87,10 @@ public:
 	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
 	idx_t GetCommittedDeletedCount(idx_t max_count) override;
 
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
+	bool HasDeletes() const override;
+
+	void Write(WriteStream &writer) const override;
+	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
 
 private:
 	template <class OP>
@@ -102,13 +106,13 @@ public:
 	explicit ChunkVectorInfo(idx_t start);
 
 	//! The transaction ids of the transactions that inserted the tuples (if any)
-	atomic<transaction_t> inserted[STANDARD_VECTOR_SIZE];
-	atomic<transaction_t> insert_id;
-	atomic<bool> same_inserted_id;
+	transaction_t inserted[STANDARD_VECTOR_SIZE];
+	transaction_t insert_id;
+	bool same_inserted_id;
 
 	//! The transaction ids of the transactions that deleted the tuples (if any)
-	atomic<transaction_t> deleted[STANDARD_VECTOR_SIZE];
-	atomic<bool> any_deleted;
+	transaction_t deleted[STANDARD_VECTOR_SIZE];
+	bool any_deleted;
 
 public:
 	idx_t GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
@@ -130,8 +134,10 @@ public:
 	idx_t Delete(transaction_t transaction_id, row_t rows[], idx_t count);
 	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
 
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
+	bool HasDeletes() const override;
+
+	void Write(WriteStream &writer) const override;
+	static unique_ptr<ChunkInfo> Read(ReadStream &reader);
 
 private:
 	template <class OP>

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -68,37 +68,22 @@ struct PartialBlockForCheckpoint : public PartialBlock {
 	};
 
 public:
-	PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, BlockManager &block_manager,
-	                          PartialBlockState state);
+	PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
+	                          BlockManager &block_manager);
 	~PartialBlockForCheckpoint() override;
 
 	// We will copy all segment data into the memory of the shared block.
 	// Once the block is full (or checkpoint is complete) we'll invoke Flush().
 	// This will cause the block to get written to storage (via BlockManger::ConvertToPersistent),
 	// and all segments to have their references updated (via ColumnSegment::ConvertToPersistent)
-	BlockManager &block_manager;
-	shared_ptr<BlockHandle> block;
 	vector<PartialColumnSegment> segments;
 
-private:
-	struct UninitializedRegion {
-		idx_t start;
-		idx_t end;
-	};
-	vector<UninitializedRegion> uninitialized_regions;
-
 public:
 	bool IsFlushed();
-
-	void AddUninitializedRegion(idx_t start, idx_t end) override;
-
-	void Flush(idx_t free_space_left) override;
-
-	void Clear() override;
-
+	void Flush(const idx_t free_space_left) override;
 	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
-
 	void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block);
+	void Clear() override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/column_data.hpp

@@ -151,7 +151,7 @@ protected:
 	void AppendTransientSegment(SegmentLock &l, idx_t start_row);
 
 	//! Scans a base vector from the column
-	idx_t ScanVector(ColumnScanState &state, Vector &result, idx_t remaining);
+	idx_t ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, bool has_updates);
 	//! Scans a vector from the column merged with any potential updates
 	//! If ALLOW_UPDATES is set to false, the function will instead throw an exception if any updates are found
 	template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -36,11 +36,12 @@ class Vector;
 struct ColumnCheckpointState;
 struct RowGroupPointer;
 struct TransactionData;
-struct VersionNode;
 class CollectionScanState;
 class TableFilterSet;
 struct ColumnFetchState;
 struct RowGroupAppendState;
+class MetadataManager;
+class RowVersionManager;
 
 struct RowGroupWriteData {
 	vector<unique_ptr<ColumnCheckpointState>> states;
@@ -50,11 +51,6 @@ struct RowGroupWriteData {
 class RowGroup : public SegmentBase<RowGroup> {
 public:
 	friend class ColumnData;
-	friend class VersionDeleteState;
-
-public:
-	static constexpr const idx_t ROW_GROUP_SIZE = STANDARD_ROW_GROUPS_SIZE;
-	static constexpr const idx_t ROW_GROUP_VECTOR_COUNT = ROW_GROUP_SIZE / STANDARD_VECTOR_SIZE;
 
 public:
 	RowGroup(RowGroupCollection &collection, idx_t start, idx_t count);
@@ -65,7 +61,7 @@ private:
 	//! The RowGroupCollection this row-group is a part of
 	reference<RowGroupCollection> collection;
 	//! The version info of the row_group (inserted and deleted tuple info)
-	shared_ptr<VersionNode> version_info;
+	shared_ptr<RowVersionManager> version_info;
 	//! The column data of the row_group
 	vector<shared_ptr<ColumnData>> columns;
 
@@ -145,12 +141,17 @@ public:
 
 	void NextVector(CollectionScanState &state);
 
+	idx_t DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count);
+	RowVersionManager &GetOrCreateVersionInfo();
+
 	// Serialization
 	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
 	static RowGroupPointer Deserialize(Deserializer &deserializer);
 
 private:
-	ChunkInfo *GetChunkInfo(idx_t vector_idx);
+	shared_ptr<RowVersionManager> &GetVersionInfo();
+	shared_ptr<RowVersionManager> &GetOrCreateVersionInfoPtr();
+
 	ColumnData &GetColumn(storage_t c);
 	idx_t GetColumnCount() const;
 	vector<shared_ptr<ColumnData>> &GetColumns();
@@ -158,18 +159,17 @@ private:
 	template <TableScanType TYPE>
 	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
 
+	vector<MetaBlockPointer> CheckpointDeletes(MetadataManager &manager);
+
+	bool HasUnloadedDeletes() const;
+
 private:
 	mutex row_group_lock;
 	mutex stats_lock;
 	vector<MetaBlockPointer> column_pointers;
 	unique_ptr<atomic<bool>[]> is_loaded;
-};
-
-struct VersionNode {
-	unique_ptr<ChunkInfo> info[RowGroup::ROW_GROUP_VECTOR_COUNT];
-
-	void SetStart(idx_t start);
-	idx_t GetCommittedDeletedCount(idx_t count);
+	vector<MetaBlockPointer> deletes_pointers;
+	atomic<bool> deletes_is_loaded;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/row_version_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/vector_size.hpp"
+#include "duckdb/storage/table/chunk_info.hpp"
+#include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/mutex.hpp"
+
+namespace duckdb {
+
+class MetadataManager;
+struct MetaBlockPointer;
+
+class RowVersionManager {
+public:
+	explicit RowVersionManager(idx_t start);
+
+	idx_t GetStart() {
+		return start;
+	}
+	void SetStart(idx_t start);
+	idx_t GetCommittedDeletedCount(idx_t count);
+
+	idx_t GetSelVector(TransactionData transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count);
+	idx_t GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
+	                            SelectionVector &sel_vector, idx_t max_count);
+	bool Fetch(TransactionData transaction, idx_t row);
+
+	void AppendVersionInfo(TransactionData transaction, idx_t count, idx_t row_group_start, idx_t row_group_end);
+	void CommitAppend(transaction_t commit_id, idx_t row_group_start, idx_t count);
+	void RevertAppend(idx_t start_row);
+
+	idx_t DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count);
+	void CommitDelete(idx_t vector_idx, transaction_t commit_id, row_t rows[], idx_t count);
+
+	vector<MetaBlockPointer> Checkpoint(MetadataManager &manager);
+	static shared_ptr<RowVersionManager> Deserialize(MetaBlockPointer delete_pointer, MetadataManager &manager,
+	                                                 idx_t start);
+
+private:
+	mutex version_lock;
+	idx_t start;
+	unique_ptr<ChunkInfo> vector_info[Storage::ROW_GROUP_VECTOR_COUNT];
+	bool has_changes;
+	vector<MetaBlockPointer> storage_pointers;
+
+private:
+	optional_ptr<ChunkInfo> GetChunkInfo(idx_t vector_idx);
+	ChunkVectorInfo &GetVectorInfo(idx_t vector_idx);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp

@@ -101,7 +101,7 @@ struct UpdateNodeData {
 };
 
 struct UpdateNode {
-	unique_ptr<UpdateNodeData> info[RowGroup::ROW_GROUP_VECTOR_COUNT];
+	unique_ptr<UpdateNodeData> info[Storage::ROW_GROUP_VECTOR_COUNT];
 };
 
 } // namespace duckdb