duckdb 0.8.2-dev37.0 → 0.8.2-dev3949.0

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

@@ -3,469 +3,439 @@
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix_segment.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 {
 
-void Prefix::Free(ART &art) {
+Prefix &Prefix::New(ART &art, Node &node) {
 
-	if (IsInlined()) {
-		return Initialize();
-	}
-
-	// delete all prefix segments
-	auto ptr = data.ptr;
-	while (ptr.IsSet()) {
-		auto next_ptr = PrefixSegment::Get(art, ptr).next;
-		Node::Free(art, ptr);
-		ptr = next_ptr;
-	}
+	node = Node::GetAllocator(art, NType::PREFIX).New();
+	node.SetType((uint8_t)NType::PREFIX);
 
-	Initialize();
+	auto &prefix = Prefix::Get(art, node);
+	prefix.data[Node::PREFIX_SIZE] = 0;
+	return prefix;
 }
 
-void Prefix::Initialize(ART &art, const ARTKey &key, const uint32_t depth, const uint32_t count_p) {
+Prefix &Prefix::New(ART &art, Node &node, uint8_t byte, Node next) {
 
-	// prefix can be inlined
-	if (count_p <= Node::PREFIX_INLINE_BYTES) {
-		memcpy(data.inlined, key.data + depth, count_p);
-		count = count_p;
-		return;
-	}
+	node = Node::GetAllocator(art, NType::PREFIX).New();
+	node.SetType((uint8_t)NType::PREFIX);
 
-	// prefix cannot be inlined, copy to segment(s)
-	count = 0;
-	reference<PrefixSegment> segment(PrefixSegment::New(art, data.ptr));
-	for (idx_t i = 0; i < count_p; i++) {
-		segment = segment.get().Append(art, count, key.data[depth + i]);
-	}
-	D_ASSERT(count == count_p);
+	auto &prefix = Prefix::Get(art, node);
+	prefix.data[Node::PREFIX_SIZE] = 1;
+	prefix.data[0] = byte;
+	prefix.ptr = next;
+	return prefix;
 }
 
-void Prefix::Initialize(ART &art, const Prefix &other, const uint32_t count_p) {
+void Prefix::New(ART &art, reference<Node> &node, const ARTKey &key, const uint32_t depth, uint32_t count) {
 
-	D_ASSERT(count_p <= other.count);
-
-	// copy inlined data
-	if (other.IsInlined()) {
-		memcpy(data.inlined, other.data.inlined, count_p);
-		count = count_p;
+	if (count == 0) {
 		return;
 	}
+	idx_t copy_count = 0;
 
-	// initialize the count and get the first segment
-	count = 0;
-	reference<PrefixSegment> segment(PrefixSegment::New(art, data.ptr));
+	while (count) {
+		node.get() = Node::GetAllocator(art, NType::PREFIX).New();
+		node.get().SetType((uint8_t)NType::PREFIX);
+		auto &prefix = Prefix::Get(art, node);
 
-	// iterate the segments of the other prefix and copy their data
-	auto other_ptr = other.data.ptr;
-	auto remaining = count_p;
+		auto this_count = MinValue((uint32_t)Node::PREFIX_SIZE, count);
+		prefix.data[Node::PREFIX_SIZE] = (uint8_t)this_count;
+		memcpy(prefix.data, key.data + depth + copy_count, this_count);
 
-	while (remaining != 0) {
-		D_ASSERT(other_ptr.IsSet());
-		auto &other_segment = PrefixSegment::Get(art, other_ptr);
-		auto copy_count = MinValue(Node::PREFIX_SEGMENT_SIZE, remaining);
+		node = prefix.ptr;
+		copy_count += this_count;
+		count -= this_count;
+	}
+}
 
-		// copy the data
-		for (idx_t i = 0; i < copy_count; i++) {
-			segment = segment.get().Append(art, count, other_segment.bytes[i]);
-		}
+void Prefix::Free(ART &art, Node &node) {
 
-		// adjust the loop variables
-		other_ptr = other_segment.next;
-		remaining -= copy_count;
+	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;
+		Node::GetAllocator(art, NType::PREFIX).Free(current_node);
+		current_node = next_node;
 	}
-	D_ASSERT(count == count_p);
+
+	Node::Free(art, current_node);
+	node.Reset();
 }
 
-void Prefix::InitializeMerge(ART &art, const idx_t buffer_count) {
+void Prefix::InitializeMerge(ART &art, Node &node, const ARTFlags &flags) {
 
-	if (IsInlined()) {
-		return;
-	}
+	auto merge_buffer_count = flags.merge_buffer_counts[(uint8_t)NType::PREFIX - 1];
 
-	reference<PrefixSegment> segment(PrefixSegment::Get(art, data.ptr));
-	data.ptr.buffer_id += buffer_count;
+	Node next_node = node;
+	reference<Prefix> prefix = Prefix::Get(art, next_node);
 
-	auto ptr = segment.get().next;
-	while (ptr.IsSet()) {
-		segment.get().next.buffer_id += buffer_count;
-		segment = PrefixSegment::Get(art, ptr);
-		ptr = segment.get().next;
+	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);
+		}
 	}
+
+	node.AddToBufferID(merge_buffer_count);
+	prefix.get().ptr.InitializeMerge(art, flags);
 }
 
-void Prefix::Append(ART &art, const Prefix &other) {
+void Prefix::Concatenate(ART &art, Node &prefix_node, const uint8_t byte, Node &child_prefix_node) {
 
-	// result fits into inlined data, i.e., both prefixes are also inlined
-	if (count + other.count <= Node::PREFIX_INLINE_BYTES) {
-		memcpy(data.inlined + count, other.data.inlined, other.count);
-		count += other.count;
-		return;
-	}
+	D_ASSERT(prefix_node.IsSet() && !prefix_node.IsSerialized());
+	D_ASSERT(child_prefix_node.IsSet());
 
-	// this prefix is inlined, but will no longer be after appending the other prefix,
-	// move the inlined bytes to the first prefix segment
-	if (IsInlined()) {
-		MoveInlinedToSegment(art);
+	if (child_prefix_node.IsSerialized()) {
+		child_prefix_node.Deserialize(art);
 	}
 
-	// get the tail of the segments of this prefix
-	reference<PrefixSegment> segment(PrefixSegment::Get(art, data.ptr).GetTail(art));
+	// append a byte and a child_prefix to prefix
+	if (prefix_node.GetType() == NType::PREFIX) {
 
-	// the other prefix is inlined
-	if (other.IsInlined()) {
-		for (idx_t i = 0; i < other.count; i++) {
-			segment = segment.get().Append(art, count, other.data.inlined[i]);
-		}
-		return;
-	}
+		// get the tail
+		reference<Prefix> prefix = Prefix::Get(art, prefix_node);
+		D_ASSERT(prefix.get().ptr.IsSet() && !prefix.get().ptr.IsSerialized());
 
-	// iterate all segments of the other prefix and copy their data
-	auto other_ptr = other.data.ptr;
-	auto remaining = other.count;
+		while (prefix.get().ptr.GetType() == NType::PREFIX) {
+			prefix = Prefix::Get(art, prefix.get().ptr);
+			D_ASSERT(prefix.get().ptr.IsSet() && !prefix.get().ptr.IsSerialized());
+		}
 
-	while (other_ptr.IsSet()) {
-		auto &other_segment = PrefixSegment::Get(art, other_ptr);
-		auto copy_count = MinValue(Node::PREFIX_SEGMENT_SIZE, remaining);
+		// append the byte
+		prefix = prefix.get().Append(art, byte);
 
-		// copy the data
-		for (idx_t i = 0; i < copy_count; i++) {
-			segment = segment.get().Append(art, count, other_segment.bytes[i]);
+		if (child_prefix_node.GetType() == NType::PREFIX) {
+			// append the child prefix
+			prefix.get().Append(art, child_prefix_node);
+		} else {
+			// set child_prefix_node to succeed prefix
+			prefix.get().ptr = child_prefix_node;
 		}
+		return;
+	}
+
+	// create a new prefix node containing the byte, then append the child_prefix to it
+	if (prefix_node.GetType() != NType::PREFIX && child_prefix_node.GetType() == NType::PREFIX) {
 
-		// adjust the loop variables
-		other_ptr = other_segment.next;
-		remaining -= copy_count;
+		auto child_prefix = child_prefix_node;
+		auto &prefix = Prefix::New(art, prefix_node, byte, Node());
+		prefix.Append(art, child_prefix);
+		return;
 	}
-	D_ASSERT(remaining == 0);
+
+	// neither prefix nor child_prefix are prefix nodes
+	// create a new prefix containing the byte
+	Prefix::New(art, prefix_node, byte, child_prefix_node);
 }
 
-void Prefix::Concatenate(ART &art, const uint8_t byte, const Prefix &other) {
+idx_t Prefix::Traverse(ART &art, reference<Node> &prefix_node, const ARTKey &key, idx_t &depth) {
 
-	auto new_size = count + 1 + other.count;
+	D_ASSERT(prefix_node.get().IsSet() && !prefix_node.get().IsSerialized());
+	D_ASSERT(prefix_node.get().GetType() == NType::PREFIX);
 
-	// overwrite into this prefix (both are inlined)
-	if (new_size <= Node::PREFIX_INLINE_BYTES) {
-		// move this prefix backwards
-		memmove(data.inlined + other.count + 1, data.inlined, count);
-		// copy byte
-		data.inlined[other.count] = byte;
-		// copy the other prefix into this prefix
-		memcpy(data.inlined, other.data.inlined, other.count);
-		count = new_size;
-		return;
+	// compare prefix nodes to key bytes
+	while (prefix_node.get().GetType() == NType::PREFIX) {
+		auto &prefix = Prefix::Get(art, prefix_node);
+		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().IsSet());
+		if (prefix_node.get().IsSerialized()) {
+			prefix_node.get().Deserialize(art);
+		}
 	}
 
-	auto this_inlined = IsInlined();
-	auto this_count = count;
-	auto this_data = data;
-	Initialize();
+	return DConstants::INVALID_INDEX;
+}
 
-	// append the other prefix and possibly move the data to a segment
-	Append(art, other);
-	if (IsInlined()) {
-		MoveInlinedToSegment(art);
-	}
+bool Prefix::Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &mismatch_position) {
 
-	// get the tail
-	reference<PrefixSegment> segment(PrefixSegment::Get(art, data.ptr).GetTail(art));
-	// append the byte
-	segment = segment.get().Append(art, count, byte);
+	auto &l_prefix = Prefix::Get(art, l_node.get());
+	auto &r_prefix = Prefix::Get(art, r_node.get());
 
-	if (this_inlined) {
-		// append this prefix
-		for (idx_t i = 0; i < this_count; i++) {
-			segment = segment.get().Append(art, count, this_data.inlined[i]);
+	// compare prefix bytes
+	idx_t max_count = MinValue(l_prefix.data[Node::PREFIX_SIZE], r_prefix.data[Node::PREFIX_SIZE]);
+	for (idx_t i = 0; i < max_count; i++) {
+		if (l_prefix.data[i] != r_prefix.data[i]) {
+			mismatch_position = i;
+			break;
 		}
-		return;
 	}
 
-	// iterate all segments of this prefix, copy their data, and free them
-	auto this_ptr = this_data.ptr;
-	auto remaining = this_count;
-
-	while (this_ptr.IsSet()) {
-		auto &this_segment = PrefixSegment::Get(art, this_ptr);
-		auto copy_count = MinValue(Node::PREFIX_SEGMENT_SIZE, remaining);
+	if (mismatch_position == DConstants::INVALID_INDEX) {
 
-		// copy the data
-		for (idx_t i = 0; i < copy_count; i++) {
-			segment = segment.get().Append(art, count, this_segment.bytes[i]);
+		// prefixes match (so far)
+		if (l_prefix.data[Node::PREFIX_SIZE] == r_prefix.data[Node::PREFIX_SIZE]) {
+			return l_prefix.ptr.ResolvePrefixes(art, r_prefix.ptr);
 		}
 
-		// adjust the loop variables
-		Node::Free(art, this_ptr);
-		this_ptr = this_segment.next;
-		remaining -= copy_count;
+		mismatch_position = max_count;
+
+		// l_prefix contains r_prefix
+		if (r_prefix.ptr.GetType() != NType::PREFIX && r_prefix.data[Node::PREFIX_SIZE] == max_count) {
+			swap(l_node.get(), r_node.get());
+			l_node = r_prefix.ptr;
+
+		} else {
+			// r_prefix contains l_prefix
+			l_node = l_prefix.ptr;
+		}
 	}
-	D_ASSERT(remaining == 0);
+
+	return true;
 }
 
-uint8_t Prefix::Reduce(ART &art, const idx_t reduce_count) {
+void Prefix::Reduce(ART &art, Node &prefix_node, const idx_t n) {
+
+	D_ASSERT(prefix_node.IsSet() && !prefix_node.IsSerialized());
+	D_ASSERT(n < Node::PREFIX_SIZE);
 
-	auto new_count = count - reduce_count - 1;
-	auto new_first_byte = GetByte(art, reduce_count);
+	reference<Prefix> prefix = Prefix::Get(art, prefix_node);
 
-	// prefix is now empty
-	if (new_count == 0) {
-		Free(art);
-		return new_first_byte;
+	// 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();
+		Node::Free(art, prefix_node);
+		prefix_node = next_ptr;
+		return;
 	}
 
-	// was inlined, just move bytes
-	if (IsInlined()) {
-		memmove(data.inlined, data.inlined + reduce_count + 1, new_count);
-		count = new_count;
-		return new_first_byte;
+	// shift by n bytes in the current prefix
+	for (idx_t i = 0; i < Node::PREFIX_SIZE - n - 1; i++) {
+		prefix.get().data[i] = prefix.get().data[n + i + 1];
 	}
+	D_ASSERT(n < (idx_t)(prefix.get().data[Node::PREFIX_SIZE] - 1));
+	prefix.get().data[Node::PREFIX_SIZE] -= n + 1;
 
-	count = 0;
-	auto start = reduce_count + 1;
-	auto offset = start % Node::PREFIX_SEGMENT_SIZE;
-	auto remaining = new_count;
+	// append the remaining prefix bytes
+	prefix.get().Append(art, prefix.get().ptr);
+}
+
+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());
 
-	// get the source segment, i.e., the segment that contains the byte at start
-	reference<PrefixSegment> src_segment(PrefixSegment::Get(art, data.ptr));
-	for (idx_t i = 0; i < start / Node::PREFIX_SEGMENT_SIZE; i++) {
-		D_ASSERT(src_segment.get().next.IsSet());
-		src_segment = PrefixSegment::Get(art, src_segment.get().next);
+	auto &prefix = Prefix::Get(art, prefix_node);
+
+	// 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,
+	// then, we reference prefix.ptr, to overwrite it with a new node later
+	if (position + 1 == Node::PREFIX_SIZE) {
+		prefix.data[Node::PREFIX_SIZE]--;
+		prefix_node = prefix.ptr;
+		child_node = prefix.ptr;
+		return;
 	}
 
-	// iterate all segments starting at the source segment and shift their data
-	reference<PrefixSegment> dst_segment(PrefixSegment::Get(art, data.ptr));
-	while (true) {
-		auto copy_count = MinValue(Node::PREFIX_SEGMENT_SIZE - offset, remaining);
+	// append the remaining bytes after the split
+	if (position + 1 < prefix.data[Node::PREFIX_SIZE]) {
+		reference<Prefix> child_prefix = 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]);
+		}
 
-		// copy the data
-		for (idx_t i = offset; i < offset + copy_count; i++) {
-			dst_segment = dst_segment.get().Append(art, count, src_segment.get().bytes[i]);
+		D_ASSERT(prefix.ptr.IsSet());
+		if (prefix.ptr.IsSerialized()) {
+			prefix.ptr.Deserialize(art);
 		}
 
-		// adjust the loop variables
-		offset = 0;
-		remaining -= copy_count;
-		if (remaining == 0) {
-			break;
+		if (prefix.ptr.GetType() == NType::PREFIX) {
+			child_prefix.get().Append(art, prefix.ptr);
+		} else {
+			// this is the last prefix node of the prefix
+			child_prefix.get().ptr = prefix.ptr;
 		}
-		D_ASSERT(src_segment.get().next.IsSet());
-		src_segment = PrefixSegment::Get(art, src_segment.get().next);
 	}
 
-	// possibly inline the data
-	if (IsInlined()) {
-		MoveSegmentToInlined(art);
+	// this is the last prefix node of the prefix
+	if (position + 1 == prefix.data[Node::PREFIX_SIZE]) {
+		child_node = prefix.ptr;
 	}
 
-	return new_first_byte;
-}
-
-uint8_t Prefix::GetByte(const ART &art, const idx_t position) const {
-
-	D_ASSERT(position < count);
-	if (IsInlined()) {
-		return data.inlined[position];
-	}
+	// set the new size of this node
+	prefix.data[Node::PREFIX_SIZE] = position;
 
-	// get the correct segment
-	reference<PrefixSegment> segment(PrefixSegment::Get(art, data.ptr));
-	for (idx_t i = 0; i < position / Node::PREFIX_SEGMENT_SIZE; i++) {
-		D_ASSERT(segment.get().next.IsSet());
-		segment = PrefixSegment::Get(art, segment.get().next);
+	// no bytes left before the split, free this node
+	if (position == 0) {
+		prefix.ptr.Reset();
+		Node::Free(art, prefix_node.get());
+		return;
 	}
 
-	return segment.get().bytes[position % Node::PREFIX_SEGMENT_SIZE];
+	// bytes left before the split, reference subsequent node
+	prefix_node = prefix.ptr;
+	return;
 }
 
-uint32_t Prefix::KeyMismatchPosition(const ART &art, const ARTKey &key, const uint32_t depth) const {
-
-	if (IsInlined()) {
-		for (idx_t mismatch_position = 0; mismatch_position < count; mismatch_position++) {
-			D_ASSERT(depth + mismatch_position < key.len);
-			if (key[depth + mismatch_position] != data.inlined[mismatch_position]) {
-				return mismatch_position;
-			}
-		}
-		return count;
-	}
+string Prefix::VerifyAndToString(ART &art, Node &node, const bool only_verify) {
 
-	uint32_t mismatch_position = 0;
-	auto ptr = data.ptr;
+	// NOTE: we could do this recursively, but the function-call overhead can become kinda crazy
+	string str = "";
 
-	while (mismatch_position != count) {
-		D_ASSERT(depth + mismatch_position < key.len);
-		D_ASSERT(ptr.IsSet());
+	reference<Node> node_ref(node);
+	while (node_ref.get().GetType() == NType::PREFIX) {
 
-		auto &segment = PrefixSegment::Get(art, ptr);
-		auto compare_count = MinValue(Node::PREFIX_SEGMENT_SIZE, count - mismatch_position);
+		auto &prefix = Prefix::Get(art, node_ref);
+		D_ASSERT(prefix.data[Node::PREFIX_SIZE] != 0);
+		D_ASSERT(prefix.data[Node::PREFIX_SIZE] <= Node::PREFIX_SIZE);
 
-		// compare bytes
-		for (uint32_t i = 0; i < compare_count; i++) {
-			if (key[depth + mismatch_position] != segment.bytes[i]) {
-				return mismatch_position;
-			}
-			mismatch_position++;
+		str += " prefix_bytes:[";
+		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
+			str += to_string(prefix.data[i]) + "-";
 		}
+		str += "] ";
 
-		// adjust loop variables
-		ptr = segment.next;
+		if (prefix.ptr.IsSerialized()) {
+			return str + " serialized";
+		}
+		node_ref = prefix.ptr;
 	}
-	return count;
+
+	return str + node_ref.get().VerifyAndToString(art, only_verify);
 }
 
-uint32_t Prefix::MismatchPosition(const ART &art, const Prefix &other) const {
+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);
 
-	D_ASSERT(count <= other.count);
+	// get pointer and write fields
+	auto block_pointer = writer.GetBlockPointer();
+	writer.Write(NType::PREFIX);
+	writer.Write<idx_t>(total_count);
 
-	// case 1: both prefixes are inlined
-	if (IsInlined() && other.IsInlined()) {
-		for (uint32_t i = 0; i < count; i++) {
-			if (data.inlined[i] != other.data.inlined[i]) {
-				return i;
-			}
-		}
-		return count;
-	}
+	reference<Node> current_node(node);
+	while (current_node.get().GetType() == NType::PREFIX) {
 
-	// case 2: only this prefix is inlined
-	if (IsInlined()) {
-		// we only need the first segment of the other prefix
-		auto &segment = PrefixSegment::Get(art, other.data.ptr);
-		for (uint32_t i = 0; i < count; i++) {
-			if (data.inlined[i] != segment.bytes[i]) {
-				return i;
-			}
+		// 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]);
 		}
-		return count;
+
+		current_node = prefix.ptr;
 	}
 
-	// case 3: both prefixes are not inlined
-	auto ptr = data.ptr;
-	auto other_ptr = other.data.ptr;
-
-	// iterate segments and compare bytes
-	uint32_t mismatch_position = 0;
-	while (ptr.IsSet()) {
-		D_ASSERT(other_ptr.IsSet());
-		auto &segment = PrefixSegment::Get(art, ptr);
-		auto &other_segment = PrefixSegment::Get(art, other_ptr);
-
-		// compare bytes
-		auto compare_count = MinValue(Node::PREFIX_SEGMENT_SIZE, count - mismatch_position);
-		for (uint32_t i = 0; i < compare_count; i++) {
-			if (segment.bytes[i] != other_segment.bytes[i]) {
-				return mismatch_position;
-			}
-			mismatch_position++;
-		}
+	// write child block pointer
+	writer.Write(child_block_pointer.block_id);
+	writer.Write(child_block_pointer.offset);
 
-		// adjust loop variables
-		ptr = segment.next;
-		other_ptr = other_segment.next;
-	}
-	return count;
+	return block_pointer;
 }
 
-void Prefix::Serialize(const ART &art, MetaBlockWriter &writer) const {
+void Prefix::Deserialize(ART &art, Node &node, MetadataReader &reader) {
+	auto total_count = reader.Read<idx_t>();
+	reference<Node> current_node(node);
 
-	writer.Write(count);
+	while (total_count) {
+		current_node.get() = Node::GetAllocator(art, NType::PREFIX).New();
+		current_node.get().SetType((uint8_t)NType::PREFIX);
 
-	// write inlined data
-	if (IsInlined()) {
-		writer.WriteData(data.inlined, count);
-		return;
+		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();
 	}
 
-	D_ASSERT(data.ptr.IsSet());
-	auto ptr = data.ptr;
-	auto remaining = count;
+	// read child block pointer
+	current_node.get() = Node(reader);
+}
 
-	// iterate all prefix segments and write their bytes
-	while (ptr.IsSet()) {
-		auto &segment = PrefixSegment::Get(art, ptr);
-		auto copy_count = MinValue(Node::PREFIX_SEGMENT_SIZE, remaining);
+void Prefix::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
 
-		// write the bytes
-		writer.WriteData(segment.bytes, copy_count);
+	bool flag_set = flags.vacuum_flags[(uint8_t)NType::PREFIX - 1];
+	auto &allocator = Node::GetAllocator(art, NType::PREFIX);
 
-		// adjust loop variables
-		remaining -= copy_count;
-		ptr = segment.next;
+	reference<Node> node_ref(node);
+	while (!node_ref.get().IsSerialized() && 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);
+		}
+		auto &prefix = Prefix::Get(art, node_ref);
+		node_ref = prefix.ptr;
 	}
-	D_ASSERT(remaining == 0);
+
+	node_ref.get().Vacuum(art, flags);
 }
 
-void Prefix::Deserialize(ART &art, MetaBlockReader &reader) {
+Prefix &Prefix::Append(ART &art, const uint8_t byte) {
 
-	auto count_p = reader.Read<uint32_t>();
+	reference<Prefix> prefix(*this);
 
-	// copy into inlined data
-	if (count_p <= Node::PREFIX_INLINE_BYTES) {
-		reader.ReadData(data.inlined, count_p);
-		count = count_p;
-		return;
+	// we need a new prefix node
+	if (prefix.get().data[Node::PREFIX_SIZE] == Node::PREFIX_SIZE) {
+		prefix = Prefix::New(art, prefix.get().ptr);
 	}
 
-	// copy into segments
-	count = 0;
-	reference<PrefixSegment> segment(PrefixSegment::New(art, data.ptr));
-	for (idx_t i = 0; i < count_p; i++) {
-		segment = segment.get().Append(art, count, reader.Read<uint8_t>());
-	}
-	D_ASSERT(count_p == count);
+	prefix.get().data[prefix.get().data[Node::PREFIX_SIZE]] = byte;
+	prefix.get().data[Node::PREFIX_SIZE]++;
+	return prefix.get();
 }
 
-void Prefix::Vacuum(ART &art) {
+void Prefix::Append(ART &art, Node other_prefix) {
 
-	if (IsInlined()) {
-		return;
-	}
+	// NOTE: all usages of this function already deserialize the other prefix
+	D_ASSERT(other_prefix.IsSet() && !other_prefix.IsSerialized());
 
-	// first pointer has special treatment because we don't obtain it from a prefix segment
-	auto &allocator = Node::GetAllocator(art, NType::PREFIX_SEGMENT);
-	if (allocator.NeedsVacuum(data.ptr)) {
-		data.ptr.SetPtr(allocator.VacuumPointer(data.ptr));
-		data.ptr.type = (uint8_t)NType::PREFIX_SEGMENT;
-	}
+	reference<Prefix> prefix(*this);
+	while (other_prefix.GetType() == NType::PREFIX) {
 
-	auto ptr = data.ptr;
-	while (ptr.IsSet()) {
-		auto &segment = PrefixSegment::Get(art, ptr);
-		ptr = segment.next;
-		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
-			segment.next.SetPtr(allocator.VacuumPointer(ptr));
-			segment.next.type = (uint8_t)NType::PREFIX_SEGMENT;
-			ptr = segment.next;
+		// copy prefix bytes
+		auto &other = Prefix::Get(art, other_prefix);
+		for (idx_t i = 0; i < other.data[Node::PREFIX_SIZE]; i++) {
+			prefix = prefix.get().Append(art, other.data[i]);
 		}
-	}
-}
-
-PrefixSegment &Prefix::MoveInlinedToSegment(ART &art) {
 
-	D_ASSERT(IsInlined());
+		D_ASSERT(other.ptr.IsSet());
+		if (other.ptr.IsSerialized()) {
+			other.ptr.Deserialize(art);
+		}
 
-	Node ptr;
-	auto &segment = PrefixSegment::New(art, ptr);
+		prefix.get().ptr = other.ptr;
+		Node::GetAllocator(art, NType::PREFIX).Free(other_prefix);
+		other_prefix = prefix.get().ptr;
+	}
 
-	// move data
-	D_ASSERT(Node::PREFIX_SEGMENT_SIZE >= Node::PREFIX_INLINE_BYTES);
-	memcpy(segment.bytes, data.inlined, count);
-	data.ptr = ptr;
-	return segment;
+	D_ASSERT(prefix.get().ptr.GetType() != NType::PREFIX);
 }
 
-void Prefix::MoveSegmentToInlined(ART &art) {
+idx_t Prefix::TotalCount(ART &art, reference<Node> &node) {
 
-	D_ASSERT(IsInlined());
-	D_ASSERT(data.ptr.IsSet());
+	// NOTE: first prefix in the prefix chain is already deserialized
+	D_ASSERT(node.get().IsSet() && !node.get().IsSerialized());
 
-	auto ptr = data.ptr;
-	auto &segment = PrefixSegment::Get(art, data.ptr);
+	idx_t count = 0;
+	while (node.get().GetType() == NType::PREFIX) {
+		auto &prefix = Prefix::Get(art, node);
+		count += prefix.data[Node::PREFIX_SIZE];
 
-	memcpy(data.inlined, segment.bytes, count);
-	Node::Free(art, ptr);
+		if (prefix.ptr.IsSerialized()) {
+			prefix.ptr.Deserialize(art);
+		}
+		node = prefix.ptr;
+	}
+	return count;
 }
 
 } // namespace duckdb