duckdb 0.8.2-dev2669.0 → 0.8.2-dev2700.0

package/binding.gyp

@@ -136,6 +136,7 @@
                 "src/duckdb/ub_src_storage_checkpoint.cpp", 
                 "src/duckdb/ub_src_storage_compression.cpp", 
                 "src/duckdb/ub_src_storage_compression_chimp.cpp", 
+                "src/duckdb/ub_src_storage_metadata.cpp", 
                 "src/duckdb/ub_src_storage_serialization.cpp", 
                 "src/duckdb/ub_src_storage_statistics.cpp", 
                 "src/duckdb/ub_src_storage_table.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2669.0",
+  "version": "0.8.2-dev2700.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -23,7 +23,7 @@
 namespace duckdb {
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	// fetch types and create expressions for the index from the columns
 	vector<column_t> column_ids;
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -41,9 +41,9 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 	}
 	unique_ptr<ART> art;
 	// create an adaptive radix tree around the expressions
-	if (index_block) {
+	if (index_block.IsValid()) {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db, nullptr, index_block->block_id, index_block->offset);
+		                     storage.db, nullptr, index_block);
 	} else {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
 		                     storage.db);
@@ -55,7 +55,7 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 }
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	vector<PhysicalIndex> new_keys;
 	new_keys.reserve(keys.size());
 	for (auto &logical_key : keys) {
@@ -92,7 +92,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 				if (info.indexes.empty()) {
 					AddDataTableIndex(*storage, columns, unique.keys, constraint_type);
 				} else {
-					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, &info.indexes[indexes_idx++]);
+					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, info.indexes[indexes_idx++]);
 				}
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
 				// foreign key constraint: create a foreign key index
@@ -103,7 +103,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
 					} else {
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-						                  &info.indexes[indexes_idx++]);
+						                  info.indexes[indexes_idx++]);
 					}
 				}
 			}

package/src/duckdb/src/common/field_writer.cpp

@@ -72,6 +72,7 @@ FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count
 	max_field_count = source_p.Read<uint32_t>();
 	total_size = source_p.Read<uint64_t>();
 	D_ASSERT(max_field_count > 0);
+	D_ASSERT(total_size > 0);
 	source.SetRemainingData(total_size);
 }
 

package/src/duckdb/src/common/local_file_system.cpp

@@ -267,6 +267,11 @@ void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, i
 		if (bytes_read == -1) {
 			throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
 		}
+		if (bytes_read == 0) {
+			throw IOException(
+			    "Could not read enough bytes from file \"%s\": attempted to read %llu bytes from location %llu",
+			    handle.path, nr_bytes, location);
+		}
 		read_buffer += bytes_read;
 		nr_bytes -= bytes_read;
 	}

package/src/duckdb/src/common/types/interval.cpp

@@ -116,6 +116,9 @@ interval_parse_time : {
 	}
 	result.micros += time.micros;
 	found_any = true;
+	if (negative) {
+		result.micros = -result.micros;
+	}
 	goto end_of_string;
 }
 interval_parse_identifier:

package/src/duckdb/src/core_functions/aggregate/nested/list.cpp

@@ -77,7 +77,12 @@ static void ListCombineFunction(Vector &states_vector, Vector &combined, Aggrega
 	for (idx_t i = 0; i < count; i++) {
 
 		auto &state = *states_ptr[states_data.sel->get_index(i)];
-		D_ASSERT(state.linked_list.total_capacity != 0);
+		if (state.linked_list.total_capacity == 0) {
+			// NULL, no need to append
+			// this can happen when adding a FILTER to the grouping, e.g.,
+			// LIST(i) FILTER (WHERE i <> 3)
+			continue;
+		}
 
 		if (combined_ptr[i]->linked_list.total_capacity == 0) {
 			combined_ptr[i]->linked_list = state.linked_list;

package/src/duckdb/src/execution/index/art/art.cpp

@@ -33,12 +33,9 @@ struct ARTIndexScanState : public IndexScanState {
 
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
-         AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr, const idx_t block_id,
-         const idx_t block_offset)
-
+         AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr, BlockPointer pointer)
     : Index(db, IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type),
       allocators(allocators_ptr), owns_data(false) {
-
 	if (!Radix::IsLittleEndian()) {
 		throw NotImplementedException("ART indexes are not supported on big endian architectures");
 	}
@@ -57,12 +54,12 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 
 	// set the root node of the tree
 	tree = make_uniq<Node>();
-	if (block_id != DConstants::INVALID_INDEX) {
+	serialized_data_pointer = pointer;
+	if (pointer.IsValid()) {
 		tree->SetSerialized();
-		tree->SetPtr(block_id, block_offset);
+		tree->SetPtr(pointer.block_id, pointer.offset);
 		tree->Deserialize(*this);
 	}
-	serialized_data_pointer = BlockPointer(block_id, block_offset);
 
 	// validate the types of the key columns
 	for (idx_t i = 0; i < types.size(); i++) {
@@ -974,13 +971,13 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 // Serialization
 //===--------------------------------------------------------------------===//
 
-BlockPointer ART::Serialize(MetaBlockWriter &writer) {
+BlockPointer ART::Serialize(MetadataWriter &writer) {
 
 	lock_guard<mutex> l(lock);
 	if (tree->IsSet()) {
 		serialized_data_pointer = tree->Serialize(*this, writer);
 	} else {
-		serialized_data_pointer = {(block_id_t)DConstants::INVALID_INDEX, (uint32_t)DConstants::INVALID_INDEX};
+		serialized_data_pointer = BlockPointer();
 	}
 
 	return serialized_data_pointer;

package/src/duckdb/src/execution/index/art/leaf.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -323,7 +323,7 @@ string Leaf::VerifyAndToString(ART &art, Node &node) {
 	return str;
 }
 
-BlockPointer Leaf::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
+BlockPointer Leaf::Serialize(ART &art, Node &node, MetadataWriter &writer) {
 
 	if (node.GetType() == NType::LEAF_INLINED) {
 		auto block_pointer = writer.GetBlockPointer();
@@ -353,7 +353,7 @@ BlockPointer Leaf::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Leaf::Deserialize(ART &art, Node &node, MetaBlockReader &reader) {
+void Leaf::Deserialize(ART &art, Node &node, MetadataReader &reader) {
 
 	auto total_count = reader.Read<idx_t>();
 	reference<Node> ref_node(node);

package/src/duckdb/src/execution/index/art/node.cpp

@@ -9,8 +9,8 @@
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/leaf.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
 
 namespace duckdb {
@@ -19,13 +19,12 @@ namespace duckdb {
 // Constructors / Destructors
 //===--------------------------------------------------------------------===//
 
-Node::Node(MetaBlockReader &reader) {
-
-	idx_t block_id = reader.Read<block_id_t>();
+Node::Node(MetadataReader &reader) {
+	block_id_t block_id = reader.Read<block_id_t>();
 	auto offset = reader.Read<uint32_t>();
 	Reset();
 
-	if (block_id == DConstants::INVALID_INDEX) {
+	if (block_id == INVALID_BLOCK) {
 		return;
 	}
 
@@ -223,10 +222,9 @@ optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deseri
 // (De)serialization
 //===--------------------------------------------------------------------===//
 
-BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
-
+BlockPointer Node::Serialize(ART &art, MetadataWriter &writer) {
 	if (!IsSet()) {
-		return {(block_id_t)DConstants::INVALID_INDEX, 0};
+		return BlockPointer();
 	}
 	if (IsSerialized()) {
 		Deserialize(art);
@@ -254,11 +252,10 @@ BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 }
 
 void Node::Deserialize(ART &art) {
-
 	D_ASSERT(IsSet() && IsSerialized());
 
-	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), GetBufferId());
-	reader.offset = GetOffset();
+	BlockPointer pointer(GetBufferId(), GetOffset());
+	MetadataReader reader(art.table_io_manager.GetMetadataManager(), pointer);
 	Reset();
 	SetType(reader.Read<uint8_t>());
 

package/src/duckdb/src/execution/index/art/node16.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -173,7 +173,7 @@ optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node16::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -203,7 +203,7 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node16::Deserialize(MetaBlockReader &reader) {
+void Node16::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();
 

package/src/duckdb/src/execution/index/art/node256.cpp

@@ -1,8 +1,8 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -109,7 +109,7 @@ optional_ptr<Node> Node256::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node256::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -131,7 +131,7 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node256::Deserialize(MetaBlockReader &reader) {
+void Node256::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint16_t>();
 

package/src/duckdb/src/execution/index/art/node4.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/prefix.hpp"
 #include "duckdb/execution/index/art/node16.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -166,7 +166,7 @@ optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node4::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -196,8 +196,7 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node4::Deserialize(MetaBlockReader &reader) {
-
+void Node4::Deserialize(MetadataReader &reader) {
 	count = reader.Read<uint8_t>();
 
 	// read key values

package/src/duckdb/src/execution/index/art/node48.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -168,7 +168,7 @@ optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node48::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -195,7 +195,7 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node48::Deserialize(MetaBlockReader &reader) {
+void Node48::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();
 

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -3,8 +3,8 @@
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/common/swap.hpp"
 
 namespace duckdb {
@@ -306,8 +306,7 @@ string Prefix::VerifyAndToString(ART &art, Node &node, const bool only_verify) {
 	return str + node_ref.get().VerifyAndToString(art, only_verify);
 }
 
-BlockPointer Prefix::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
-
+BlockPointer Prefix::Serialize(ART &art, Node &node, MetadataWriter &writer) {
 	reference<Node> first_non_prefix(node);
 	idx_t total_count = Prefix::TotalCount(art, first_non_prefix);
 	auto child_block_pointer = first_non_prefix.get().Serialize(art, writer);
@@ -337,8 +336,7 @@ BlockPointer Prefix::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Prefix::Deserialize(ART &art, Node &node, MetaBlockReader &reader) {
-
+void Prefix::Deserialize(ART &art, Node &node, MetadataReader &reader) {
 	auto total_count = reader.Read<idx_t>();
 	reference<Node> current_node(node);
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2669"
+#define DUCKDB_VERSION "0.8.2-dev2700"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c6f10389c3"
+#define DUCKDB_SOURCE_ID "acbbfe0e79"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/catalog/standard_entry.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 

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

@@ -36,7 +36,7 @@ public:
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
 	    AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr = nullptr,
-	    const idx_t block_id = DConstants::INVALID_INDEX, const idx_t block_offset = DConstants::INVALID_INDEX);
+	    BlockPointer block = BlockPointer());
 	~ART() override;
 
 	//! Root of the tree
@@ -80,7 +80,7 @@ public:
 	void SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size);
 
 	//! Serializes the index and returns the pair of block_id offset positions
-	BlockPointer Serialize(MetaBlockWriter &writer) override;
+	BlockPointer Serialize(MetadataWriter &writer) override;
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge

package/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp

@@ -15,8 +15,8 @@
 namespace duckdb {
 
 // classes
-class MetaBlockWriter;
-class MetaBlockReader;
+class MetadataWriter;
+class MetadataReader;
 
 // structs
 struct BlockPointer;
@@ -70,9 +70,9 @@ public:
 	static string VerifyAndToString(ART &art, Node &node);
 
 	//! Serialize the leaf (chain)
-	static BlockPointer Serialize(ART &art, Node &node, MetaBlockWriter &writer);
+	static BlockPointer Serialize(ART &art, Node &node, MetadataWriter &writer);
 	//! Deserialize the leaf (chain)
-	static void Deserialize(ART &art, Node &node, MetaBlockReader &reader);
+	static void Deserialize(ART &art, Node &node, MetadataReader &reader);
 
 	//! Vacuum the leaf (chain)
 	static void Vacuum(ART &art, Node &node);

package/src/duckdb/src/include/duckdb/execution/index/art/node.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/limits.hpp"
 
 namespace duckdb {
 
@@ -28,12 +29,13 @@ enum class NType : uint8_t {
 class FixedSizeAllocator;
 class ART;
 class Prefix;
-class MetaBlockReader;
-class MetaBlockWriter;
+class MetadataReader;
+class MetadataWriter;
 
 // structs
 struct BlockPointer;
 struct ARTFlags;
+struct MetaBlockPointer;
 
 //! The Node is the pointer class of the ART index.
 //! If the node is serialized, then the pointer points to a storage address (and has no type),
@@ -70,7 +72,7 @@ public:
 	//! Constructs an empty Node
 	Node() : data(0) {};
 	//! Constructs a serialized Node pointer from a block ID and an offset
-	explicit Node(MetaBlockReader &reader);
+	explicit Node(MetadataReader &reader);
 	//! Constructs an in-memory Node from a buffer ID and an offset
 	Node(const uint32_t buffer_id, const uint32_t offset) : data(0) {
 		SetPtr(buffer_id, offset);
@@ -95,7 +97,7 @@ public:
 	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte, const bool deserialize = true) const;
 
 	//! Serialize the node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	BlockPointer Serialize(ART &art, MetadataWriter &writer);
 	//! Deserialize the node
 	void Deserialize(ART &art);
 

package/src/duckdb/src/include/duckdb/execution/index/art/node16.hpp

@@ -56,9 +56,9 @@ public:
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
 	//! Serialize this node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	BlockPointer Serialize(ART &art, MetadataWriter &writer);
 	//! Deserialize this node
-	void Deserialize(MetaBlockReader &reader);
+	void Deserialize(MetadataReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

package/src/duckdb/src/include/duckdb/execution/index/art/node256.hpp

@@ -59,9 +59,9 @@ public:
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
 	//! Serialize this node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	BlockPointer Serialize(ART &art, MetadataWriter &writer);
 	//! Deserialize this node
-	void Deserialize(MetaBlockReader &reader);
+	void Deserialize(MetadataReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

package/src/duckdb/src/include/duckdb/execution/index/art/node4.hpp

@@ -54,9 +54,9 @@ public:
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
 	//! Serialize this node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	BlockPointer Serialize(ART &art, MetadataWriter &writer);
 	//! Deserialize this node
-	void Deserialize(MetaBlockReader &reader);
+	void Deserialize(MetadataReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

package/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp

@@ -66,9 +66,9 @@ public:
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
 	//! Serialize this node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	BlockPointer Serialize(ART &art, MetadataWriter &writer);
 	//! Deserialize this node
-	void Deserialize(MetaBlockReader &reader);
+	void Deserialize(MetadataReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

package/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp

@@ -74,9 +74,9 @@ public:
 	static string VerifyAndToString(ART &art, Node &node, const bool only_verify);
 
 	//! Serialize this node and all subsequent nodes
-	static BlockPointer Serialize(ART &art, Node &node, MetaBlockWriter &writer);
+	static BlockPointer Serialize(ART &art, Node &node, MetadataWriter &writer);
 	//! Deserialize this node and all subsequent prefix nodes
-	static void Deserialize(ART &art, Node &node, MetaBlockReader &reader);
+	static void Deserialize(ART &art, Node &node, MetadataReader &reader);
 
 	//! Vacuum the child of the node
 	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);

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

@@ -24,10 +24,33 @@ public:
 };
 
 struct BlockPointer {
-	BlockPointer(block_id_t block_id_p, uint32_t offset_p) : block_id(block_id_p), offset(offset_p) {};
-	BlockPointer() {};
-	block_id_t block_id {0};
-	uint32_t offset {0};
+	BlockPointer(block_id_t block_id_p, uint32_t offset_p) : block_id(block_id_p), offset(offset_p) {
+	}
+	BlockPointer() : block_id(INVALID_BLOCK), offset(0) {
+	}
+
+	block_id_t block_id;
+	uint32_t offset;
+
+	bool IsValid() {
+		return block_id != INVALID_BLOCK;
+	}
+};
+
+struct MetaBlockPointer {
+	MetaBlockPointer(idx_t block_pointer, uint32_t offset_p) : block_pointer(block_pointer), offset(offset_p) {
+	}
+	MetaBlockPointer() : block_pointer(DConstants::INVALID_INDEX), offset(0) {
+	}
+
+	idx_t block_pointer;
+	uint32_t offset;
+
+	bool IsValid() {
+		return block_pointer != DConstants::INVALID_INDEX;
+	}
+	block_id_t GetBlockId();
+	uint32_t GetBlockIndex();
 };
 
 } // namespace duckdb