duckdb 0.8.2-dev4025.0 → 0.8.2-dev4142.0

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

@@ -2,16 +2,14 @@
 
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
 Node48 &Node48::New(ART &art, Node &node) {
 
 	node = Node::GetAllocator(art, NType::NODE_48).New();
-	node.SetType((uint8_t)NType::NODE_48);
-	auto &n48 = Node48::Get(art, node);
+	node.SetMetadata(static_cast<uint8_t>(NType::NODE_48));
+	auto &n48 = Node::RefMutable<Node48>(art, node, NType::NODE_48);
 
 	n48.count = 0;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -20,7 +18,7 @@ Node48 &Node48::New(ART &art, Node &node) {
 
 	// necessary for faster child insertion/deletion
 	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
-		n48.children[i].Reset();
+		n48.children[i].Clear();
 	}
 
 	return n48;
@@ -28,10 +26,8 @@ Node48 &Node48::New(ART &art, Node &node) {
 
 void Node48::Free(ART &art, Node &node) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-
-	auto &n48 = Node48::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n48 = Node::RefMutable<Node48>(art, node, NType::NODE_48);
 
 	if (!n48.count) {
 		return;
@@ -47,8 +43,8 @@ void Node48::Free(ART &art, Node &node) {
 
 Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 
-	auto &n16 = Node16::Get(art, node16);
-	auto &n48 = Node48::New(art, node48);
+	auto &n16 = Node::RefMutable<Node16>(art, node16, NType::NODE_16);
+	auto &n48 = New(art, node48);
 
 	n48.count = n16.count;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -62,7 +58,7 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 
 	// necessary for faster child insertion/deletion
 	for (idx_t i = n16.count; i < Node::NODE_48_CAPACITY; i++) {
-		n48.children[i].Reset();
+		n48.children[i].Clear();
 	}
 
 	n16.count = 0;
@@ -72,13 +68,13 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 
 Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 
-	auto &n48 = Node48::New(art, node48);
-	auto &n256 = Node256::Get(art, node256);
+	auto &n48 = New(art, node48);
+	auto &n256 = Node::RefMutable<Node256>(art, node256, NType::NODE_256);
 
 	n48.count = 0;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n48.count <= Node::NODE_48_CAPACITY);
-		if (n256.children[i].IsSet()) {
+		if (n256.children[i].HasMetadata()) {
 			n48.child_index[i] = n48.count;
 			n48.children[n48.count] = n256.children[i];
 			n48.count++;
@@ -89,7 +85,7 @@ Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 
 	// necessary for faster child insertion/deletion
 	for (idx_t i = n48.count; i < Node::NODE_48_CAPACITY; i++) {
-		n48.children[i].Reset();
+		n48.children[i].Clear();
 	}
 
 	n256.count = 0;
@@ -108,9 +104,8 @@ void Node48::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n48 = Node48::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n48 = Node::RefMutable<Node48>(art, node, NType::NODE_48);
 
 	// ensure that there is no other child at the same byte
 	D_ASSERT(n48.child_index[byte] == Node::EMPTY_MARKER);
@@ -119,10 +114,10 @@ void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 	if (n48.count < Node::NODE_48_CAPACITY) {
 		// still space, just insert the child
 		idx_t child_pos = n48.count;
-		if (n48.children[child_pos].IsSet()) {
+		if (n48.children[child_pos].HasMetadata()) {
 			// find an empty position in the node list if the current position is occupied
 			child_pos = 0;
-			while (n48.children[child_pos].IsSet()) {
+			while (n48.children[child_pos].HasMetadata()) {
 				child_pos++;
 			}
 		}
@@ -140,9 +135,8 @@ void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 
 void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n48 = Node48::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n48 = Node::RefMutable<Node48>(art, node, NType::NODE_48);
 
 	// free the child and decrease the count
 	Node::Free(art, n48.children[n48.child_index[byte]]);
@@ -156,58 +150,42 @@ void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 	}
 }
 
-optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
+optional_ptr<const Node> Node48::GetChild(const uint8_t byte) const {
+	if (child_index[byte] != Node::EMPTY_MARKER) {
+		D_ASSERT(children[child_index[byte]].HasMetadata());
+		return &children[child_index[byte]];
+	}
+	return nullptr;
+}
+
+optional_ptr<Node> Node48::GetChildMutable(const uint8_t byte) {
+	if (child_index[byte] != Node::EMPTY_MARKER) {
+		D_ASSERT(children[child_index[byte]].HasMetadata());
+		return &children[child_index[byte]];
+	}
+	return nullptr;
+}
 
+optional_ptr<const Node> Node48::GetNextChild(uint8_t &byte) const {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
 			byte = i;
-			D_ASSERT(children[child_index[i]].IsSet());
+			D_ASSERT(children[child_index[i]].HasMetadata());
 			return &children[child_index[i]];
 		}
 	}
 	return nullptr;
 }
 
-BlockPointer Node48::Serialize(ART &art, MetadataWriter &writer) {
-
-	// recurse into children and retrieve child block pointers
-	vector<BlockPointer> child_block_pointers;
-	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
-		child_block_pointers.push_back(children[i].Serialize(art, writer));
-	}
-
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::NODE_48);
-	writer.Write<uint8_t>(count);
-
-	// write key values
-	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		writer.Write(child_index[i]);
-	}
-
-	// write child block pointers
-	for (auto &child_block_pointer : child_block_pointers) {
-		writer.Write(child_block_pointer.block_id);
-		writer.Write(child_block_pointer.offset);
-	}
-
-	return block_pointer;
-}
-
-void Node48::Deserialize(MetadataReader &reader) {
-
-	count = reader.Read<uint8_t>();
-
-	// read key values
-	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		child_index[i] = reader.Read<uint8_t>();
-	}
-
-	// read child block pointers
-	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
-		children[i] = Node(reader);
+optional_ptr<Node> Node48::GetNextChildMutable(uint8_t &byte) {
+	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
+		if (child_index[i] != Node::EMPTY_MARKER) {
+			byte = i;
+			D_ASSERT(children[child_index[i]].HasMetadata());
+			return &children[child_index[i]];
+		}
 	}
+	return nullptr;
 }
 
 void Node48::Vacuum(ART &art, const ARTFlags &flags) {

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

@@ -3,8 +3,6 @@
 #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/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/common/swap.hpp"
 
 namespace duckdb {
@@ -12,19 +10,19 @@ namespace duckdb {
 Prefix &Prefix::New(ART &art, Node &node) {
 
 	node = Node::GetAllocator(art, NType::PREFIX).New();
-	node.SetType((uint8_t)NType::PREFIX);
+	node.SetMetadata(static_cast<uint8_t>(NType::PREFIX));
 
-	auto &prefix = Prefix::Get(art, node);
+	auto &prefix = Node::RefMutable<Prefix>(art, node, NType::PREFIX);
 	prefix.data[Node::PREFIX_SIZE] = 0;
 	return prefix;
 }
 
-Prefix &Prefix::New(ART &art, Node &node, uint8_t byte, Node next) {
+Prefix &Prefix::New(ART &art, Node &node, uint8_t byte, const Node &next) {
 
 	node = Node::GetAllocator(art, NType::PREFIX).New();
-	node.SetType((uint8_t)NType::PREFIX);
+	node.SetMetadata(static_cast<uint8_t>(NType::PREFIX));
 
-	auto &prefix = Prefix::Get(art, node);
+	auto &prefix = Node::RefMutable<Prefix>(art, node, NType::PREFIX);
 	prefix.data[Node::PREFIX_SIZE] = 1;
 	prefix.data[0] = byte;
 	prefix.ptr = next;
@@ -40,8 +38,8 @@ void Prefix::New(ART &art, reference<Node> &node, const ARTKey &key, const uint3
 
 	while (count) {
 		node.get() = Node::GetAllocator(art, NType::PREFIX).New();
-		node.get().SetType((uint8_t)NType::PREFIX);
-		auto &prefix = Prefix::Get(art, node);
+		node.get().SetMetadata(static_cast<uint8_t>(NType::PREFIX));
+		auto &prefix = Node::RefMutable<Prefix>(art, node, NType::PREFIX);
 
 		auto this_count = MinValue((uint32_t)Node::PREFIX_SIZE, count);
 		prefix.data[Node::PREFIX_SIZE] = (uint8_t)this_count;
@@ -57,54 +55,49 @@ void Prefix::Free(ART &art, Node &node) {
 
 	Node current_node = node;
 	Node next_node;
-	while (current_node.IsSet() && !current_node.IsSerialized() && current_node.GetType() == NType::PREFIX) {
-		next_node = Prefix::Get(art, current_node).ptr;
+	while (current_node.HasMetadata() && current_node.GetType() == NType::PREFIX) {
+		next_node = Node::RefMutable<Prefix>(art, current_node, NType::PREFIX).ptr;
 		Node::GetAllocator(art, NType::PREFIX).Free(current_node);
 		current_node = next_node;
 	}
 
 	Node::Free(art, current_node);
-	node.Reset();
+	node.Clear();
 }
 
 void Prefix::InitializeMerge(ART &art, Node &node, const ARTFlags &flags) {
 
-	auto merge_buffer_count = flags.merge_buffer_counts[(uint8_t)NType::PREFIX - 1];
+	auto merge_buffer_count = flags.merge_buffer_counts[static_cast<uint8_t>(NType::PREFIX) - 1];
 
 	Node next_node = node;
-	reference<Prefix> prefix = Prefix::Get(art, next_node);
+	reference<Prefix> prefix = Node::RefMutable<Prefix>(art, next_node, NType::PREFIX);
 
 	while (next_node.GetType() == NType::PREFIX) {
 		next_node = prefix.get().ptr;
 		if (prefix.get().ptr.GetType() == NType::PREFIX) {
-			prefix.get().ptr.AddToBufferID(merge_buffer_count);
-			prefix = Prefix::Get(art, next_node);
+			prefix.get().ptr.IncreaseBufferId(merge_buffer_count);
+			prefix = Node::RefMutable<Prefix>(art, next_node, NType::PREFIX);
 		}
 	}
 
-	node.AddToBufferID(merge_buffer_count);
+	node.IncreaseBufferId(merge_buffer_count);
 	prefix.get().ptr.InitializeMerge(art, flags);
 }
 
 void Prefix::Concatenate(ART &art, Node &prefix_node, const uint8_t byte, Node &child_prefix_node) {
 
-	D_ASSERT(prefix_node.IsSet() && !prefix_node.IsSerialized());
-	D_ASSERT(child_prefix_node.IsSet());
-
-	if (child_prefix_node.IsSerialized()) {
-		child_prefix_node.Deserialize(art);
-	}
+	D_ASSERT(prefix_node.HasMetadata() && child_prefix_node.HasMetadata());
 
 	// append a byte and a child_prefix to prefix
 	if (prefix_node.GetType() == NType::PREFIX) {
 
 		// get the tail
-		reference<Prefix> prefix = Prefix::Get(art, prefix_node);
-		D_ASSERT(prefix.get().ptr.IsSet() && !prefix.get().ptr.IsSerialized());
+		reference<Prefix> prefix = Node::RefMutable<Prefix>(art, prefix_node, NType::PREFIX);
+		D_ASSERT(prefix.get().ptr.HasMetadata());
 
 		while (prefix.get().ptr.GetType() == NType::PREFIX) {
-			prefix = Prefix::Get(art, prefix.get().ptr);
-			D_ASSERT(prefix.get().ptr.IsSet() && !prefix.get().ptr.IsSerialized());
+			prefix = Node::RefMutable<Prefix>(art, prefix.get().ptr, NType::PREFIX);
+			D_ASSERT(prefix.get().ptr.HasMetadata());
 		}
 
 		// append the byte
@@ -124,24 +117,24 @@ void Prefix::Concatenate(ART &art, Node &prefix_node, const uint8_t byte, Node &
 	if (prefix_node.GetType() != NType::PREFIX && child_prefix_node.GetType() == NType::PREFIX) {
 
 		auto child_prefix = child_prefix_node;
-		auto &prefix = Prefix::New(art, prefix_node, byte, Node());
+		auto &prefix = New(art, prefix_node, byte);
 		prefix.Append(art, child_prefix);
 		return;
 	}
 
 	// neither prefix nor child_prefix are prefix nodes
 	// create a new prefix containing the byte
-	Prefix::New(art, prefix_node, byte, child_prefix_node);
+	New(art, prefix_node, byte, child_prefix_node);
 }
 
-idx_t Prefix::Traverse(ART &art, reference<Node> &prefix_node, const ARTKey &key, idx_t &depth) {
+idx_t Prefix::Traverse(ART &art, reference<const Node> &prefix_node, const ARTKey &key, idx_t &depth) {
 
-	D_ASSERT(prefix_node.get().IsSet() && !prefix_node.get().IsSerialized());
+	D_ASSERT(prefix_node.get().HasMetadata());
 	D_ASSERT(prefix_node.get().GetType() == NType::PREFIX);
 
 	// compare prefix nodes to key bytes
 	while (prefix_node.get().GetType() == NType::PREFIX) {
-		auto &prefix = Prefix::Get(art, prefix_node);
+		auto &prefix = Node::Ref<const Prefix>(art, prefix_node, NType::PREFIX);
 		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
 			if (prefix.data[i] != key[depth]) {
 				return i;
@@ -149,10 +142,28 @@ idx_t Prefix::Traverse(ART &art, reference<Node> &prefix_node, const ARTKey &key
 			depth++;
 		}
 		prefix_node = prefix.ptr;
-		D_ASSERT(prefix_node.get().IsSet());
-		if (prefix_node.get().IsSerialized()) {
-			prefix_node.get().Deserialize(art);
+		D_ASSERT(prefix_node.get().HasMetadata());
+	}
+
+	return DConstants::INVALID_INDEX;
+}
+
+idx_t Prefix::TraverseMutable(ART &art, reference<Node> &prefix_node, const ARTKey &key, idx_t &depth) {
+
+	D_ASSERT(prefix_node.get().HasMetadata());
+	D_ASSERT(prefix_node.get().GetType() == NType::PREFIX);
+
+	// compare prefix nodes to key bytes
+	while (prefix_node.get().GetType() == NType::PREFIX) {
+		auto &prefix = Node::RefMutable<Prefix>(art, prefix_node, NType::PREFIX);
+		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
+			if (prefix.data[i] != key[depth]) {
+				return i;
+			}
+			depth++;
 		}
+		prefix_node = prefix.ptr;
+		D_ASSERT(prefix_node.get().HasMetadata());
 	}
 
 	return DConstants::INVALID_INDEX;
@@ -160,8 +171,8 @@ idx_t Prefix::Traverse(ART &art, reference<Node> &prefix_node, const ARTKey &key
 
 bool Prefix::Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &mismatch_position) {
 
-	auto &l_prefix = Prefix::Get(art, l_node.get());
-	auto &r_prefix = Prefix::Get(art, r_node.get());
+	auto &l_prefix = Node::RefMutable<Prefix>(art, l_node.get(), NType::PREFIX);
+	auto &r_prefix = Node::RefMutable<Prefix>(art, r_node.get(), NType::PREFIX);
 
 	// compare prefix bytes
 	idx_t max_count = MinValue(l_prefix.data[Node::PREFIX_SIZE], r_prefix.data[Node::PREFIX_SIZE]);
@@ -197,16 +208,16 @@ bool Prefix::Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node
 
 void Prefix::Reduce(ART &art, Node &prefix_node, const idx_t n) {
 
-	D_ASSERT(prefix_node.IsSet() && !prefix_node.IsSerialized());
+	D_ASSERT(prefix_node.HasMetadata());
 	D_ASSERT(n < Node::PREFIX_SIZE);
 
-	reference<Prefix> prefix = Prefix::Get(art, prefix_node);
+	reference<Prefix> prefix = Node::RefMutable<Prefix>(art, prefix_node, NType::PREFIX);
 
 	// free this prefix node
 	if (n == (idx_t)(prefix.get().data[Node::PREFIX_SIZE] - 1)) {
 		auto next_ptr = prefix.get().ptr;
-		D_ASSERT(next_ptr.IsSet());
-		prefix.get().ptr.Reset();
+		D_ASSERT(next_ptr.HasMetadata());
+		prefix.get().ptr.Clear();
 		Node::Free(art, prefix_node);
 		prefix_node = next_ptr;
 		return;
@@ -225,9 +236,9 @@ void Prefix::Reduce(ART &art, Node &prefix_node, const idx_t n) {
 
 void Prefix::Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx_t position) {
 
-	D_ASSERT(prefix_node.get().IsSet() && !prefix_node.get().IsSerialized());
+	D_ASSERT(prefix_node.get().HasMetadata());
 
-	auto &prefix = Prefix::Get(art, prefix_node);
+	auto &prefix = Node::RefMutable<Prefix>(art, prefix_node, NType::PREFIX);
 
 	// the split is at the last byte of this prefix, so the child_node contains all subsequent
 	// prefix nodes (prefix.ptr) (if any), and the count of this prefix decreases by one,
@@ -241,15 +252,12 @@ void Prefix::Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx
 
 	// append the remaining bytes after the split
 	if (position + 1 < prefix.data[Node::PREFIX_SIZE]) {
-		reference<Prefix> child_prefix = Prefix::New(art, child_node);
+		reference<Prefix> child_prefix = New(art, child_node);
 		for (idx_t i = position + 1; i < prefix.data[Node::PREFIX_SIZE]; i++) {
 			child_prefix = child_prefix.get().Append(art, prefix.data[i]);
 		}
 
-		D_ASSERT(prefix.ptr.IsSet());
-		if (prefix.ptr.IsSerialized()) {
-			prefix.ptr.Deserialize(art);
-		}
+		D_ASSERT(prefix.ptr.HasMetadata());
 
 		if (prefix.ptr.GetType() == NType::PREFIX) {
 			child_prefix.get().Append(art, prefix.ptr);
@@ -269,7 +277,7 @@ void Prefix::Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx
 
 	// no bytes left before the split, free this node
 	if (position == 0) {
-		prefix.ptr.Reset();
+		prefix.ptr.Clear();
 		Node::Free(art, prefix_node.get());
 		return;
 	}
@@ -279,15 +287,15 @@ void Prefix::Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx
 	return;
 }
 
-string Prefix::VerifyAndToString(ART &art, Node &node, const bool only_verify) {
+string Prefix::VerifyAndToString(ART &art, const Node &node, const bool only_verify) {
 
 	// NOTE: we could do this recursively, but the function-call overhead can become kinda crazy
 	string str = "";
 
-	reference<Node> node_ref(node);
+	reference<const Node> node_ref(node);
 	while (node_ref.get().GetType() == NType::PREFIX) {
 
-		auto &prefix = Prefix::Get(art, node_ref);
+		auto &prefix = Node::Ref<const Prefix>(art, node_ref, NType::PREFIX);
 		D_ASSERT(prefix.data[Node::PREFIX_SIZE] != 0);
 		D_ASSERT(prefix.data[Node::PREFIX_SIZE] <= Node::PREFIX_SIZE);
 
@@ -297,82 +305,25 @@ string Prefix::VerifyAndToString(ART &art, Node &node, const bool only_verify) {
 		}
 		str += "] ";
 
-		if (prefix.ptr.IsSerialized()) {
-			return str + " serialized";
-		}
 		node_ref = prefix.ptr;
 	}
 
-	return str + node_ref.get().VerifyAndToString(art, only_verify);
-}
-
-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);
-
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::PREFIX);
-	writer.Write<idx_t>(total_count);
-
-	reference<Node> current_node(node);
-	while (current_node.get().GetType() == NType::PREFIX) {
-
-		// write prefix bytes
-		D_ASSERT(!current_node.get().IsSerialized());
-		auto &prefix = Prefix::Get(art, current_node);
-		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
-			writer.Write(prefix.data[i]);
-		}
-
-		current_node = prefix.ptr;
-	}
-
-	// write child block pointer
-	writer.Write(child_block_pointer.block_id);
-	writer.Write(child_block_pointer.offset);
-
-	return block_pointer;
-}
-
-void Prefix::Deserialize(ART &art, Node &node, MetadataReader &reader) {
-	auto total_count = reader.Read<idx_t>();
-	reference<Node> current_node(node);
-
-	while (total_count) {
-		current_node.get() = Node::GetAllocator(art, NType::PREFIX).New();
-		current_node.get().SetType((uint8_t)NType::PREFIX);
-
-		auto &prefix = Prefix::Get(art, current_node);
-		prefix.data[Node::PREFIX_SIZE] = MinValue((idx_t)Node::PREFIX_SIZE, total_count);
-
-		// read bytes
-		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
-			prefix.data[i] = reader.Read<uint8_t>();
-		}
-
-		total_count -= prefix.data[Node::PREFIX_SIZE];
-		current_node = prefix.ptr;
-		prefix.ptr.Reset();
-	}
-
-	// read child block pointer
-	current_node.get() = Node(reader);
+	auto subtree = node_ref.get().VerifyAndToString(art, only_verify);
+	return only_verify ? "" : str + subtree;
 }
 
 void Prefix::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
 
-	bool flag_set = flags.vacuum_flags[(uint8_t)NType::PREFIX - 1];
+	bool flag_set = flags.vacuum_flags[static_cast<uint8_t>(NType::PREFIX) - 1];
 	auto &allocator = Node::GetAllocator(art, NType::PREFIX);
 
 	reference<Node> node_ref(node);
-	while (!node_ref.get().IsSerialized() && node_ref.get().GetType() == NType::PREFIX) {
+	while (node_ref.get().GetType() == NType::PREFIX) {
 		if (flag_set && allocator.NeedsVacuum(node_ref)) {
 			node_ref.get() = allocator.VacuumPointer(node_ref);
-			node_ref.get().SetType((uint8_t)NType::PREFIX);
+			node_ref.get().SetMetadata(static_cast<uint8_t>(NType::PREFIX));
 		}
-		auto &prefix = Prefix::Get(art, node_ref);
+		auto &prefix = Node::RefMutable<Prefix>(art, node_ref, NType::PREFIX);
 		node_ref = prefix.ptr;
 	}
 
@@ -385,7 +336,7 @@ Prefix &Prefix::Append(ART &art, const uint8_t byte) {
 
 	// we need a new prefix node
 	if (prefix.get().data[Node::PREFIX_SIZE] == Node::PREFIX_SIZE) {
-		prefix = Prefix::New(art, prefix.get().ptr);
+		prefix = New(art, prefix.get().ptr);
 	}
 
 	prefix.get().data[prefix.get().data[Node::PREFIX_SIZE]] = byte;
@@ -395,22 +346,18 @@ Prefix &Prefix::Append(ART &art, const uint8_t byte) {
 
 void Prefix::Append(ART &art, Node other_prefix) {
 
-	// NOTE: all usages of this function already deserialize the other prefix
-	D_ASSERT(other_prefix.IsSet() && !other_prefix.IsSerialized());
+	D_ASSERT(other_prefix.HasMetadata());
 
 	reference<Prefix> prefix(*this);
 	while (other_prefix.GetType() == NType::PREFIX) {
 
 		// copy prefix bytes
-		auto &other = Prefix::Get(art, other_prefix);
+		auto &other = Node::RefMutable<Prefix>(art, other_prefix, NType::PREFIX);
 		for (idx_t i = 0; i < other.data[Node::PREFIX_SIZE]; i++) {
 			prefix = prefix.get().Append(art, other.data[i]);
 		}
 
-		D_ASSERT(other.ptr.IsSet());
-		if (other.ptr.IsSerialized()) {
-			other.ptr.Deserialize(art);
-		}
+		D_ASSERT(other.ptr.HasMetadata());
 
 		prefix.get().ptr = other.ptr;
 		Node::GetAllocator(art, NType::PREFIX).Free(other_prefix);
@@ -420,22 +367,4 @@ void Prefix::Append(ART &art, Node other_prefix) {
 	D_ASSERT(prefix.get().ptr.GetType() != NType::PREFIX);
 }
 
-idx_t Prefix::TotalCount(ART &art, reference<Node> &node) {
-
-	// NOTE: first prefix in the prefix chain is already deserialized
-	D_ASSERT(node.get().IsSet() && !node.get().IsSerialized());
-
-	idx_t count = 0;
-	while (node.get().GetType() == NType::PREFIX) {
-		auto &prefix = Prefix::Get(art, node);
-		count += prefix.data[Node::PREFIX_SIZE];
-
-		if (prefix.ptr.IsSerialized()) {
-			prefix.ptr.Deserialize(art);
-		}
-		node = prefix.ptr;
-	}
-	return count;
-}
-
 } // namespace duckdb