duckdb 0.8.2-dev1.0 → 0.8.2-dev1182.0

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

@@ -1,15 +1,15 @@
+#include "duckdb/execution/index/art/node.hpp"
+
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/swap.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/leaf_segment.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
+#include "duckdb/execution/index/art/node16.hpp"
+#include "duckdb/execution/index/art/node4.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
+#include "duckdb/execution/index/art/leaf_segment.hpp"
 #include "duckdb/execution/index/art/prefix.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/table_io_manager.hpp"
@@ -28,13 +28,9 @@ Node::Node(MetaBlockReader &reader) : SwizzleablePointer(reader) {
 
 void Node::New(ART &art, Node &node, const NType type) {
 
+	// NOTE: leaves and prefixes should not pass through this function
+
 	switch (type) {
-	case NType::PREFIX_SEGMENT:
-		PrefixSegment::New(art, node);
-		break;
-	case NType::LEAF_SEGMENT:
-		LeafSegment::New(art, node);
-		break;
 	case NType::NODE_4:
 		Node4::New(art, node);
 		break;
@@ -55,20 +51,18 @@ void Node::New(ART &art, Node &node, const NType type) {
 void Node::Free(ART &art, Node &node) {
 
 	// recursively free all nodes that are in-memory, and skip swizzled and empty nodes
-
 	if (!node.IsSet()) {
 		return;
 	}
 
 	if (!node.IsSwizzled()) {
 
+		// free the children of the nodes
 		auto type = node.DecodeARTNodeType();
-		if (type != NType::PREFIX_SEGMENT && type != NType::LEAF_SEGMENT) {
-			node.GetPrefix(art).Free(art);
-		}
-
-		// free the prefixes and children of the nodes
 		switch (type) {
+		case NType::PREFIX:
+			Prefix::Free(art, node);
+			break;
 		case NType::LEAF_SEGMENT:
 			LeafSegment::Free(art, node);
 			break;
@@ -87,8 +81,6 @@ void Node::Free(ART &art, Node &node) {
 		case NType::NODE_256:
 			Node256::Free(art, node);
 			break;
-		default:
-			break;
 		}
 
 		Node::GetAllocator(art, type).Free(node);
@@ -140,11 +132,11 @@ void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chil
 // Deletes
 //===--------------------------------------------------------------------===//
 
-void Node::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
 	switch (node.DecodeARTNodeType()) {
 	case NType::NODE_4:
-		return Node4::DeleteChild(art, node, byte);
+		return Node4::DeleteChild(art, node, prefix, byte);
 	case NType::NODE_16:
 		return Node16::DeleteChild(art, node, byte);
 	case NType::NODE_48:
@@ -227,12 +219,13 @@ BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 	if (!IsSet()) {
 		return {(block_id_t)DConstants::INVALID_INDEX, 0};
 	}
-
 	if (IsSwizzled()) {
 		Deserialize(art);
 	}
 
 	switch (DecodeARTNodeType()) {
+	case NType::PREFIX:
+		return Prefix::Get(art, *this).Serialize(art, writer);
 	case NType::LEAF:
 		return Leaf::Get(art, *this).Serialize(art, writer);
 	case NType::NODE_4:
@@ -260,16 +253,18 @@ void Node::Deserialize(ART &art) {
 	type = (uint8_t)decoded_type;
 
 	switch (decoded_type) {
+	case NType::PREFIX:
+		return Prefix::Get(art, *this).Deserialize(reader);
 	case NType::LEAF:
 		return Leaf::Get(art, *this).Deserialize(art, reader);
 	case NType::NODE_4:
-		return Node4::Get(art, *this).Deserialize(art, reader);
+		return Node4::Get(art, *this).Deserialize(reader);
 	case NType::NODE_16:
-		return Node16::Get(art, *this).Deserialize(art, reader);
+		return Node16::Get(art, *this).Deserialize(reader);
 	case NType::NODE_48:
-		return Node48::Get(art, *this).Deserialize(art, reader);
+		return Node48::Get(art, *this).Deserialize(reader);
 	case NType::NODE_256:
-		return Node256::Get(art, *this).Deserialize(art, reader);
+		return Node256::Get(art, *this).Deserialize(reader);
 	default:
 		throw InternalException("Invalid node type for Deserialize.");
 	}
@@ -291,13 +286,19 @@ string Node::VerifyAndToString(ART &art, const bool only_verify) {
 		auto str = Leaf::Get(art, *this).VerifyAndToString(art, only_verify);
 		return only_verify ? "" : "\n" + str;
 	}
+	if (type == NType::PREFIX) {
+		auto str = Prefix::Get(art, *this).VerifyAndToString(art, only_verify);
+		return only_verify ? "" : "\n" + str;
+	}
 
 	string str = "Node" + to_string(GetCapacity()) + ": [";
 
 	idx_t child_count = 0;
 	uint8_t byte = 0;
 	auto child = GetNextChild(art, byte, false);
+
 	while (child) {
+
 		child_count++;
 		if (child->IsSwizzled()) {
 			if (!only_verify) {
@@ -309,6 +310,7 @@ string Node::VerifyAndToString(ART &art, const bool only_verify) {
 				break;
 			}
 		}
+
 		byte++;
 		child = GetNextChild(art, byte, false);
 	}
@@ -337,28 +339,6 @@ idx_t Node::GetCapacity() const {
 	}
 }
 
-Prefix &Node::GetPrefix(ART &art) {
-
-	if (IsSwizzled()) {
-		Deserialize(art);
-	}
-
-	switch (DecodeARTNodeType()) {
-	case NType::LEAF:
-		return Leaf::Get(art, *this).prefix;
-	case NType::NODE_4:
-		return Node4::Get(art, *this).prefix;
-	case NType::NODE_16:
-		return Node16::Get(art, *this).prefix;
-	case NType::NODE_48:
-		return Node48::Get(art, *this).prefix;
-	case NType::NODE_256:
-		return Node256::Get(art, *this).prefix;
-	default:
-		throw InternalException("Invalid node type for GetPrefix.");
-	}
-}
-
 NType Node::GetARTNodeTypeByCount(const idx_t count) {
 
 	if (count <= NODE_4_CAPACITY) {
@@ -381,22 +361,14 @@ FixedSizeAllocator &Node::GetAllocator(const ART &art, NType type) {
 
 void Node::InitializeMerge(ART &art, const ARTFlags &flags) {
 
-	if (!IsSet()) {
-		return;
-	}
-
-	if (IsSwizzled()) {
-		Deserialize(art);
-	}
-
-	// if not all prefixes are inlined
-	if (flags.merge_buffer_counts[(uint8_t)NType::PREFIX_SEGMENT - 1] != 0) {
-		// initialize prefix segments
-		GetPrefix(art).InitializeMerge(art, flags.merge_buffer_counts[(uint8_t)NType::PREFIX_SEGMENT - 1]);
-	}
+	// the index is fully in memory during CREATE [UNIQUE] INDEX statements
+	D_ASSERT(IsSet() && !IsSwizzled());
 
 	auto type = DecodeARTNodeType();
 	switch (type) {
+	case NType::PREFIX:
+		Prefix::Get(art, *this).InitializeMerge(art, flags);
+		break;
 	case NType::LEAF:
 		// if not all leaves are inlined
 		if (flags.merge_buffer_counts[(uint8_t)NType::LEAF_SEGMENT - 1] != 0) {
@@ -434,82 +406,108 @@ bool Node::Merge(ART &art, Node &other) {
 	return ResolvePrefixes(art, other);
 }
 
-bool Node::ResolvePrefixes(ART &art, Node &other) {
+bool MergePrefixContainsOtherPrefix(ART &art, reference<Node> &l_node, reference<Node> &r_node,
+                                    idx_t &mismatch_position) {
 
-	// NOTE: we always merge into the left ART
+	// r_node's prefix contains l_node's prefix
+	// l_node cannot be a leaf, otherwise the key represented by l_node would be a subset of another key
+	// which is not possible by our construction
+	D_ASSERT(l_node.get().DecodeARTNodeType() != NType::LEAF);
 
-	D_ASSERT(IsSet());
-	D_ASSERT(other.IsSet());
+	// test if the next byte (mismatch_position) in r_node (prefix) exists in l_node
+	auto mismatch_byte = Prefix::GetByte(art, r_node, mismatch_position);
+	auto child_node = l_node.get().GetChild(art, mismatch_byte);
 
-	// make sure that r_node has the longer (or equally long) prefix
-	if (GetPrefix(art).count > other.GetPrefix(art).count) {
-		swap(*this, other);
+	// update the prefix of r_node to only consist of the bytes after mismatch_position
+	Prefix::Reduce(art, r_node, mismatch_position);
+
+	if (!child_node) {
+		// insert r_node as a child of l_node at the empty position
+		Node::InsertChild(art, l_node, mismatch_byte, r_node);
+		r_node.get().Reset();
+		return true;
 	}
 
-	auto &l_node = *this;
-	auto &r_node = other;
-	auto &l_prefix = l_node.GetPrefix(art);
-	auto &r_prefix = r_node.GetPrefix(art);
+	// recurse
+	return child_node->ResolvePrefixes(art, r_node);
+}
 
-	auto mismatch_position = l_prefix.MismatchPosition(art, r_prefix);
+void MergePrefixesDiffer(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &mismatch_position) {
 
-	// both nodes have no prefix or the same prefix
-	if (mismatch_position == l_prefix.count && l_prefix.count == r_prefix.count) {
-		return MergeInternal(art, r_node);
-	}
+	// create a new node and insert both nodes as children
 
-	if (mismatch_position == l_prefix.count) {
-		// r_node's prefix contains l_node's prefix
-		// l_node cannot be a leaf, otherwise the key represented by l_node would be a subset of another key
-		// which is not possible by our construction
-		D_ASSERT(l_node.DecodeARTNodeType() != NType::LEAF);
+	Node l_child;
+	auto l_byte = Prefix::GetByte(art, l_node, mismatch_position);
+	Prefix::Split(art, l_node, l_child, mismatch_position);
+	Node4::New(art, l_node);
 
-		// test if the next byte (mismatch_position) in r_node (longer prefix) exists in l_node
-		auto mismatch_byte = r_prefix.GetByte(art, mismatch_position);
-		auto child_node = l_node.GetChild(art, mismatch_byte);
+	// insert children
+	Node4::InsertChild(art, l_node, l_byte, l_child);
+	auto r_byte = Prefix::GetByte(art, r_node, mismatch_position);
+	Prefix::Reduce(art, r_node, mismatch_position);
+	Node4::InsertChild(art, l_node, r_byte, r_node);
 
-		// update the prefix of r_node to only consist of the bytes after mismatch_position
-		r_prefix.Reduce(art, mismatch_position);
+	r_node.get().Reset();
+}
 
-		// insert r_node as a child of l_node at empty position
-		if (!child_node) {
-			Node::InsertChild(art, l_node, mismatch_byte, r_node);
-			r_node.Reset();
-			return true;
-		}
+bool Node::ResolvePrefixes(ART &art, Node &other) {
+
+	// NOTE: we always merge into the left ART
+
+	D_ASSERT(IsSet());
+	D_ASSERT(other.IsSet());
 
-		// recurse
-		return child_node->ResolvePrefixes(art, r_node);
+	// case 1: both nodes have no prefix
+	if (DecodeARTNodeType() != NType::PREFIX && other.DecodeARTNodeType() != NType::PREFIX) {
+		return MergeInternal(art, other);
 	}
 
-	// prefixes differ, create new node and insert both nodes as children
+	reference<Node> l_node(*this);
+	reference<Node> r_node(other);
 
-	// create new node
-	auto old_l_node = l_node;
-	auto &new_n4 = Node4::New(art, l_node);
-	new_n4.prefix.Initialize(art, l_prefix, mismatch_position);
+	idx_t mismatch_position = DConstants::INVALID_INDEX;
 
-	// insert old l_node, break up prefix of old l_node
-	auto key_byte = l_prefix.Reduce(art, mismatch_position);
-	Node4::InsertChild(art, l_node, key_byte, old_l_node);
+	// traverse prefixes
+	if (l_node.get().DecodeARTNodeType() == NType::PREFIX && r_node.get().DecodeARTNodeType() == NType::PREFIX) {
+
+		if (!Prefix::Traverse(art, l_node, r_node, mismatch_position)) {
+			return false;
+		}
+		// we already recurse because the prefixes matched (so far)
+		if (mismatch_position == DConstants::INVALID_INDEX) {
+			return true;
+		}
 
-	// insert r_node, break up prefix of r_node
-	key_byte = r_prefix.Reduce(art, mismatch_position);
-	Node4::InsertChild(art, l_node, key_byte, r_node);
+	} else {
 
-	r_node.Reset();
+		// l_prefix contains r_prefix
+		if (l_node.get().DecodeARTNodeType() == NType::PREFIX) {
+			swap(*this, other);
+		}
+		mismatch_position = 0;
+	}
+	D_ASSERT(mismatch_position != DConstants::INVALID_INDEX);
+
+	// case 2: one prefix contains the other prefix
+	if (l_node.get().DecodeARTNodeType() != NType::PREFIX && r_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		return MergePrefixContainsOtherPrefix(art, l_node, r_node, mismatch_position);
+	}
+
+	// case 3: prefixes differ at a specific byte
+	MergePrefixesDiffer(art, l_node, r_node, mismatch_position);
 	return true;
 }
 
 bool Node::MergeInternal(ART &art, Node &other) {
 
-	D_ASSERT(IsSet());
-	D_ASSERT(other.IsSet());
+	D_ASSERT(IsSet() && other.IsSet());
+	D_ASSERT(DecodeARTNodeType() != NType::PREFIX && DecodeARTNodeType() != NType::LEAF_SEGMENT);
+	D_ASSERT(other.DecodeARTNodeType() != NType::PREFIX && other.DecodeARTNodeType() != NType::LEAF_SEGMENT);
 
 	// always try to merge the smaller node into the bigger node
 	// because maybe there is enough free space in the bigger node to fit the smaller one
 	// without too much recursion
-	if (this->DecodeARTNodeType() < other.DecodeARTNodeType()) {
+	if (DecodeARTNodeType() < other.DecodeARTNodeType()) {
 		swap(*this, other);
 	}
 
@@ -524,7 +522,7 @@ bool Node::MergeInternal(ART &art, Node &other) {
 			return false;
 		}
 
-		Leaf::Get(art, *this).Merge(art, r_node);
+		Leaf::Get(art, l_node).Merge(art, r_node);
 		return true;
 	}
 
@@ -567,22 +565,17 @@ void Node::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
 		return;
 	}
 
-	// possibly vacuum prefix segments, if not all prefixes are inlined
-	bool needs_vacuum = flags.vacuum_flags[(uint8_t)NType::PREFIX_SEGMENT - 1];
-	if (needs_vacuum) {
-		// vacuum prefix segments
-		node.GetPrefix(art).Vacuum(art);
-	}
-
 	auto type = node.DecodeARTNodeType();
 	auto &allocator = Node::GetAllocator(art, type);
-	needs_vacuum = flags.vacuum_flags[node.type - 1] && allocator.NeedsVacuum(node);
+	auto needs_vacuum = flags.vacuum_flags[node.type - 1] && allocator.NeedsVacuum(node);
 	if (needs_vacuum) {
 		node.SetPtr(allocator.VacuumPointer(node));
 		node.type = (uint8_t)type;
 	}
 
 	switch (type) {
+	case NType::PREFIX:
+		return Prefix::Get(art, node).Vacuum(art, flags);
 	case NType::LEAF: {
 		// possibly vacuum leaf segments, if not all leaves are inlined
 		if (flags.vacuum_flags[(uint8_t)NType::LEAF_SEGMENT - 1]) {

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

@@ -1,7 +1,5 @@
 #include "duckdb/execution/index/art/node16.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
@@ -16,7 +14,6 @@ Node16 &Node16::New(ART &art, Node &node) {
 	auto &n16 = Node16::Get(art, node);
 
 	n16.count = 0;
-	n16.prefix.Initialize();
 	return n16;
 }
 
@@ -39,8 +36,6 @@ Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
 	auto &n16 = Node16::New(art, node16);
 
 	n16.count = n4.count;
-	n16.prefix.Move(n4.prefix);
-
 	for (idx_t i = 0; i < n4.count; i++) {
 		n16.key[i] = n4.key[i];
 		n16.children[i] = n4.children[i];
@@ -57,8 +52,6 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 	auto &n48 = Node48::Get(art, node48);
 
 	n16.count = 0;
-	n16.prefix.Move(n48.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
@@ -195,7 +188,6 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_16);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
@@ -211,10 +203,9 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node16::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node16::Deserialize(MetaBlockReader &reader) {
 
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {

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

@@ -1,7 +1,5 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/storage/meta_block_writer.hpp"
@@ -15,8 +13,6 @@ Node256 &Node256::New(ART &art, Node &node) {
 	auto &n256 = Node256::Get(art, node);
 
 	n256.count = 0;
-	n256.prefix.Initialize();
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n256.children[i].Reset();
 	}
@@ -49,8 +45,6 @@ Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
 	auto &n256 = Node256::New(art, node256);
 
 	n256.count = n48.count;
-	n256.prefix.Move(n48.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
 			n256.children[i] = n48.children[n48.child_index[i]];
@@ -127,7 +121,6 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_256);
 	writer.Write<uint16_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write child block pointers
 	for (auto &child_block_pointer : child_block_pointers) {
@@ -138,10 +131,9 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node256::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node256::Deserialize(MetaBlockReader &reader) {
 
 	count = reader.Read<uint16_t>();
-	prefix.Deserialize(art, reader);
 
 	// read child block pointers
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {

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

@@ -1,7 +1,6 @@
 #include "duckdb/execution/index/art/node4.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
+#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"
@@ -15,7 +14,6 @@ Node4 &Node4::New(ART &art, Node &node) {
 	auto &n4 = Node4::Get(art, node);
 
 	n4.count = 0;
-	n4.prefix.Initialize();
 	return n4;
 }
 
@@ -39,8 +37,6 @@ Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
 
 	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
 	n4.count = n16.count;
-	n4.prefix.Move(n16.prefix);
-
 	for (idx_t i = 0; i < n16.count; i++) {
 		n4.key[i] = n16.key[i];
 		n4.children[i] = n16.children[i];
@@ -94,7 +90,7 @@ void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chi
 	}
 }
 
-void Node4::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
 	D_ASSERT(!node.IsSwizzled());
@@ -123,13 +119,18 @@ void Node4::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 	// this is a one way node, compress
 	if (n4.count == 1) {
 
+		// we need to keep track of the old node pointer
+		// because Concatenate() might overwrite that pointer while appending bytes to
+		// the prefix (and by doing so overwriting the subsequent node with
+		// new prefix nodes)
+		auto old_n4_node = node;
+
 		// get only child and concatenate prefixes
 		auto child = *n4.GetChild(n4.key[0]);
-		child.GetPrefix(art).Concatenate(art, n4.key[0], n4.prefix);
-		n4.count--;
+		Prefix::Concatenate(art, prefix, n4.key[0], child);
 
-		Node::Free(art, node);
-		node = child;
+		n4.count--;
+		Node::Free(art, old_n4_node);
 	}
 }
 
@@ -180,7 +181,6 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_4);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
@@ -196,10 +196,9 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node4::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node4::Deserialize(MetaBlockReader &reader) {
 
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {

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

@@ -1,7 +1,5 @@
 #include "duckdb/execution/index/art/node48.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
@@ -16,8 +14,6 @@ Node48 &Node48::New(ART &art, Node &node) {
 	auto &n48 = Node48::Get(art, node);
 
 	n48.count = 0;
-	n48.prefix.Initialize();
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n48.child_index[i] = Node::EMPTY_MARKER;
 	}
@@ -55,8 +51,6 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 	auto &n48 = Node48::New(art, node48);
 
 	n48.count = n16.count;
-	n48.prefix.Move(n16.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n48.child_index[i] = Node::EMPTY_MARKER;
 	}
@@ -82,8 +76,6 @@ Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 	auto &n256 = Node256::Get(art, node256);
 
 	n48.count = 0;
-	n48.prefix.Move(n256.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n48.count <= Node::NODE_48_CAPACITY);
 		if (n256.children[i].IsSet()) {
@@ -188,7 +180,6 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_48);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -204,10 +195,9 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node48::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node48::Deserialize(MetaBlockReader &reader) {
 
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {