duckdb 0.8.2-dev1791.0 → 0.8.2-dev1862.0

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

@@ -8,7 +8,6 @@
 #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/storage/meta_block_reader.hpp"
 #include "duckdb/storage/meta_block_writer.hpp"
@@ -20,12 +19,24 @@ namespace duckdb {
 // Constructors / Destructors
 //===--------------------------------------------------------------------===//
 
-Node::Node() : SwizzleablePointer() {
-}
+Node::Node(MetaBlockReader &reader) {
+
+	idx_t block_id = reader.Read<block_id_t>();
+	auto offset = reader.Read<uint32_t>();
+	Reset();
+
+	if (block_id == DConstants::INVALID_INDEX) {
+		return;
+	}
 
-Node::Node(MetaBlockReader &reader) : SwizzleablePointer(reader) {
+	SetSerialized();
+	SetPtr(block_id, offset);
 }
 
+//===--------------------------------------------------------------------===//
+// New / Free
+//===--------------------------------------------------------------------===//
+
 void Node::New(ART &art, Node &node, const NType type) {
 
 	// NOTE: leaves and prefixes should not pass through this function
@@ -50,22 +61,19 @@ 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
+	// recursively free all nodes that are in-memory, and skip serialized and empty nodes
 	if (!node.IsSet()) {
 		return;
 	}
 
-	if (!node.IsSwizzled()) {
+	if (!node.IsSerialized()) {
 
 		// free the children of the nodes
-		auto type = node.DecodeARTNodeType();
+		auto type = node.GetType();
 		switch (type) {
 		case NType::PREFIX:
 			Prefix::Free(art, node);
 			break;
-		case NType::LEAF_SEGMENT:
-			LeafSegment::Free(art, node);
-			break;
 		case NType::LEAF:
 			Leaf::Free(art, node);
 			break;
@@ -81,6 +89,9 @@ void Node::Free(ART &art, Node &node) {
 		case NType::NODE_256:
 			Node256::Free(art, node);
 			break;
+		case NType::LEAF_INLINED:
+			node.Reset();
+			return;
 		}
 
 		Node::GetAllocator(art, type).Free(node);
@@ -96,9 +107,9 @@ void Node::Free(ART &art, Node &node) {
 
 void Node::ReplaceChild(const ART &art, const uint8_t byte, const Node child) {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(!IsSerialized());
 
-	switch (DecodeARTNodeType()) {
+	switch (GetType()) {
 	case NType::NODE_4:
 		return Node4::Get(art, *this).ReplaceChild(byte, child);
 	case NType::NODE_16:
@@ -114,7 +125,7 @@ void Node::ReplaceChild(const ART &art, const uint8_t byte, const Node child) {
 
 void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-	switch (node.DecodeARTNodeType()) {
+	switch (node.GetType()) {
 	case NType::NODE_4:
 		return Node4::InsertChild(art, node, byte, child);
 	case NType::NODE_16:
@@ -134,7 +145,7 @@ void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chil
 
 void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
-	switch (node.DecodeARTNodeType()) {
+	switch (node.GetType()) {
 	case NType::NODE_4:
 		return Node4::DeleteChild(art, node, prefix, byte);
 	case NType::NODE_16:
@@ -154,10 +165,10 @@ void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
 optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
 
-	D_ASSERT(IsSet() && !IsSwizzled());
+	D_ASSERT(IsSet() && !IsSerialized());
 
 	optional_ptr<Node> child;
-	switch (DecodeARTNodeType()) {
+	switch (GetType()) {
 	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetChild(byte);
 		break;
@@ -175,7 +186,7 @@ optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
 	}
 
 	// deserialize the ART node before returning it
-	if (child && child->IsSwizzled()) {
+	if (child && child->IsSerialized()) {
 		child->Deserialize(art);
 	}
 	return child;
@@ -183,10 +194,10 @@ optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
 
 optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deserialize) const {
 
-	D_ASSERT(IsSet() && !IsSwizzled());
+	D_ASSERT(IsSet() && !IsSerialized());
 
 	optional_ptr<Node> child;
-	switch (DecodeARTNodeType()) {
+	switch (GetType()) {
 	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetNextChild(byte);
 		break;
@@ -204,7 +215,7 @@ optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deseri
 	}
 
 	// deserialize the ART node before returning it
-	if (child && deserialize && child->IsSwizzled()) {
+	if (child && deserialize && child->IsSerialized()) {
 		child->Deserialize(art);
 	}
 	return child;
@@ -219,15 +230,15 @@ BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 	if (!IsSet()) {
 		return {(block_id_t)DConstants::INVALID_INDEX, 0};
 	}
-	if (IsSwizzled()) {
+	if (IsSerialized()) {
 		Deserialize(art);
 	}
 
-	switch (DecodeARTNodeType()) {
+	switch (GetType()) {
 	case NType::PREFIX:
 		return Prefix::Get(art, *this).Serialize(art, writer);
 	case NType::LEAF:
-		return Leaf::Get(art, *this).Serialize(art, writer);
+		return Leaf::Serialize(art, *this, writer);
 	case NType::NODE_4:
 		return Node4::Get(art, *this).Serialize(art, writer);
 	case NType::NODE_16:
@@ -236,27 +247,35 @@ BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 		return Node48::Get(art, *this).Serialize(art, writer);
 	case NType::NODE_256:
 		return Node256::Get(art, *this).Serialize(art, writer);
-	default:
-		throw InternalException("Invalid node type for Serialize.");
+	case NType::LEAF_INLINED:
+		return Leaf::Serialize(art, *this, writer);
 	}
+	throw InternalException("Invalid node type for Serialize.");
 }
 
 void Node::Deserialize(ART &art) {
 
-	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), buffer_id);
-	reader.offset = offset;
-	type = reader.Read<uint8_t>();
-	swizzle_flag = 0;
+	D_ASSERT(IsSet() && IsSerialized());
+
+	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), GetBufferId());
+	reader.offset = GetOffset();
+	Reset();
+	SetType(reader.Read<uint8_t>());
+
+	auto decoded_type = GetType();
+	if (decoded_type == NType::LEAF_INLINED) {
+		SetRowId(reader.Read<row_t>());
+		return;
+	}
 
-	auto decoded_type = DecodeARTNodeType();
-	SetPtr(Node::GetAllocator(art, decoded_type).New());
-	type = (uint8_t)decoded_type;
+	*this = Node::GetAllocator(art, decoded_type).New();
+	SetType((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);
+		return Leaf::Deserialize(art, *this, reader);
 	case NType::NODE_4:
 		return Node4::Get(art, *this).Deserialize(reader);
 	case NType::NODE_16:
@@ -277,32 +296,27 @@ void Node::Deserialize(ART &art) {
 string Node::VerifyAndToString(ART &art, const bool only_verify) {
 
 	D_ASSERT(IsSet());
-	if (IsSwizzled()) {
-		return only_verify ? "" : "swizzled";
+	if (IsSerialized()) {
+		return only_verify ? "" : "serialized";
 	}
 
-	auto type = DecodeARTNodeType();
-	if (type == NType::LEAF) {
-		auto str = Leaf::Get(art, *this).VerifyAndToString(art, only_verify);
+	if (GetType() == NType::LEAF || GetType() == NType::LEAF_INLINED) {
+		auto str = Leaf::VerifyAndToString(art, *this);
 		return only_verify ? "" : "\n" + str;
 	}
-	if (type == NType::PREFIX) {
-		auto str = Prefix::Get(art, *this).VerifyAndToString(art, only_verify);
+	if (GetType() == NType::PREFIX) {
+		auto str = Prefix::Get(art, *this).VerifyAndToString(art, *this, 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 (child->IsSerialized()) {
 			if (!only_verify) {
-				str += "(swizzled)";
+				str += "(serialized)";
 			}
 		} else {
 			str += "(" + to_string(byte) + ", " + child->VerifyAndToString(art, only_verify) + ")";
@@ -315,17 +329,14 @@ string Node::VerifyAndToString(ART &art, const bool only_verify) {
 		child = GetNextChild(art, byte, false);
 	}
 
-	(void)child_count;
-	// ensure that the child count is at least two
-	D_ASSERT(child_count > 1);
 	return only_verify ? "" : "\n" + str + "]";
 }
 
 idx_t Node::GetCapacity() const {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(!IsSerialized());
 
-	switch (DecodeARTNodeType()) {
+	switch (GetType()) {
 	case NType::NODE_4:
 		return Node::NODE_4_CAPACITY;
 	case NType::NODE_16:
@@ -362,19 +373,14 @@ FixedSizeAllocator &Node::GetAllocator(const ART &art, NType type) {
 void Node::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 	// the index is fully in memory during CREATE [UNIQUE] INDEX statements
-	D_ASSERT(IsSet() && !IsSwizzled());
+	D_ASSERT(IsSet() && !IsSerialized());
 
-	auto type = DecodeARTNodeType();
-	switch (type) {
+	switch (GetType()) {
 	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) {
-			// initialize leaf segments
-			Leaf::Get(art, *this).InitializeMerge(art, flags.merge_buffer_counts[(uint8_t)NType::LEAF_SEGMENT - 1]);
-		}
+		Leaf::InitializeMerge(art, *this, flags);
 		break;
 	case NType::NODE_4:
 		Node4::Get(art, *this).InitializeMerge(art, flags);
@@ -388,11 +394,12 @@ void Node::InitializeMerge(ART &art, const ARTFlags &flags) {
 	case NType::NODE_256:
 		Node256::Get(art, *this).InitializeMerge(art, flags);
 		break;
-	default:
-		throw InternalException("Invalid node type for InitializeMerge.");
+	case NType::LEAF_INLINED:
+		return;
 	}
 
-	buffer_id += flags.merge_buffer_counts[(uint8_t)type - 1];
+	// NOTE: this works because the rightmost 32 bits contain the buffer ID
+	data += flags.merge_buffer_counts[(uint8_t)GetType() - 1];
 }
 
 bool Node::Merge(ART &art, Node &other) {
@@ -412,7 +419,7 @@ bool MergePrefixContainsOtherPrefix(ART &art, reference<Node> &l_node, reference
 	// 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(l_node.get().GetType() != NType::LEAF && l_node.get().GetType() != NType::LEAF_INLINED);
 
 	// 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);
@@ -454,11 +461,10 @@ bool Node::ResolvePrefixes(ART &art, Node &other) {
 
 	// NOTE: we always merge into the left ART
 
-	D_ASSERT(IsSet());
-	D_ASSERT(other.IsSet());
+	D_ASSERT(IsSet() && other.IsSet());
 
 	// case 1: both nodes have no prefix
-	if (DecodeARTNodeType() != NType::PREFIX && other.DecodeARTNodeType() != NType::PREFIX) {
+	if (GetType() != NType::PREFIX && other.GetType() != NType::PREFIX) {
 		return MergeInternal(art, other);
 	}
 
@@ -468,7 +474,7 @@ bool Node::ResolvePrefixes(ART &art, Node &other) {
 	idx_t mismatch_position = DConstants::INVALID_INDEX;
 
 	// traverse prefixes
-	if (l_node.get().DecodeARTNodeType() == NType::PREFIX && r_node.get().DecodeARTNodeType() == NType::PREFIX) {
+	if (l_node.get().GetType() == NType::PREFIX && r_node.get().GetType() == NType::PREFIX) {
 
 		if (!Prefix::Traverse(art, l_node, r_node, mismatch_position)) {
 			return false;
@@ -481,7 +487,7 @@ bool Node::ResolvePrefixes(ART &art, Node &other) {
 	} else {
 
 		// l_prefix contains r_prefix
-		if (l_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		if (l_node.get().GetType() == NType::PREFIX) {
 			swap(*this, other);
 		}
 		mismatch_position = 0;
@@ -489,7 +495,7 @@ bool Node::ResolvePrefixes(ART &art, Node &other) {
 	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) {
+	if (l_node.get().GetType() != NType::PREFIX && r_node.get().GetType() == NType::PREFIX) {
 		return MergePrefixContainsOtherPrefix(art, l_node, r_node, mismatch_position);
 	}
 
@@ -501,13 +507,12 @@ bool Node::ResolvePrefixes(ART &art, Node &other) {
 bool Node::MergeInternal(ART &art, Node &other) {
 
 	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);
+	D_ASSERT(GetType() != NType::PREFIX && other.GetType() != NType::PREFIX);
 
 	// 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 (DecodeARTNodeType() < other.DecodeARTNodeType()) {
+	if (GetType() < other.GetType()) {
 		swap(*this, other);
 	}
 
@@ -515,14 +520,14 @@ bool Node::MergeInternal(ART &art, Node &other) {
 	auto &l_node = *this;
 	auto &r_node = other;
 
-	if (r_node.DecodeARTNodeType() == NType::LEAF) {
-		D_ASSERT(l_node.DecodeARTNodeType() == NType::LEAF);
+	if (r_node.GetType() == NType::LEAF || r_node.GetType() == NType::LEAF_INLINED) {
+		D_ASSERT(l_node.GetType() == NType::LEAF || l_node.GetType() == NType::LEAF_INLINED);
 
 		if (art.IsUnique()) {
 			return false;
 		}
 
-		Leaf::Get(art, l_node).Merge(art, r_node);
+		Leaf::Merge(art, l_node, r_node);
 		return true;
 	}
 
@@ -559,38 +564,42 @@ bool Node::MergeInternal(ART &art, Node &other) {
 // Vacuum
 //===--------------------------------------------------------------------===//
 
-void Node::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
+void Node::Vacuum(ART &art, const ARTFlags &flags) {
 
-	if (node.IsSwizzled()) {
+	D_ASSERT(IsSet());
+	if (IsSerialized()) {
 		return;
 	}
 
-	auto type = node.DecodeARTNodeType();
-	auto &allocator = Node::GetAllocator(art, type);
-	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;
+	auto node_type = GetType();
+	if (node_type == NType::LEAF_INLINED) {
+		return;
 	}
-
-	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]) {
-			Leaf::Get(art, node).Vacuum(art);
+	if (node_type == NType::LEAF) {
+		if (flags.vacuum_flags[(uint8_t)GetType() - 1]) {
+			Leaf::Vacuum(art, *this);
 		}
 		return;
 	}
+
+	auto &allocator = Node::GetAllocator(art, node_type);
+	auto needs_vacuum = flags.vacuum_flags[(uint8_t)GetType() - 1] && allocator.NeedsVacuum(*this);
+	if (needs_vacuum) {
+		*this = allocator.VacuumPointer(*this);
+		SetType((uint8_t)node_type);
+	}
+
+	switch (node_type) {
+	case NType::PREFIX:
+		return Prefix::Get(art, *this).Vacuum(art, flags);
 	case NType::NODE_4:
-		return Node4::Get(art, node).Vacuum(art, flags);
+		return Node4::Get(art, *this).Vacuum(art, flags);
 	case NType::NODE_16:
-		return Node16::Get(art, node).Vacuum(art, flags);
+		return Node16::Get(art, *this).Vacuum(art, flags);
 	case NType::NODE_48:
-		return Node48::Get(art, node).Vacuum(art, flags);
+		return Node48::Get(art, *this).Vacuum(art, flags);
 	case NType::NODE_256:
-		return Node256::Get(art, node).Vacuum(art, flags);
+		return Node256::Get(art, *this).Vacuum(art, flags);
 	default:
 		throw InternalException("Invalid node type for Vacuum.");
 	}

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

@@ -9,8 +9,8 @@ namespace duckdb {
 
 Node16 &Node16::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_16).New());
-	node.type = (uint8_t)NType::NODE_16;
+	node = Node::GetAllocator(art, NType::NODE_16).New();
+	node.SetType((uint8_t)NType::NODE_16);
 	auto &n16 = Node16::Get(art, node);
 
 	n16.count = 0;
@@ -20,7 +20,7 @@ Node16 &Node16::New(ART &art, Node &node) {
 void Node16::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n16 = Node16::Get(art, node);
 
@@ -76,7 +76,7 @@ void Node16::InitializeMerge(ART &art, const ARTFlags &flags) {
 void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n16 = Node16::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -112,7 +112,7 @@ void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n16 = Node16::Get(art, node);
 
 	idx_t child_pos = 0;
@@ -221,7 +221,7 @@ void Node16::Deserialize(MetaBlockReader &reader) {
 void Node16::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < count; i++) {
-		Node::Vacuum(art, children[i], flags);
+		children[i].Vacuum(art, flags);
 	}
 }
 

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

@@ -8,8 +8,8 @@ namespace duckdb {
 
 Node256 &Node256::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_256).New());
-	node.type = (uint8_t)NType::NODE_256;
+	node = Node::GetAllocator(art, NType::NODE_256).New();
+	node.SetType((uint8_t)NType::NODE_256);
 	auto &n256 = Node256::Get(art, node);
 
 	n256.count = 0;
@@ -23,7 +23,7 @@ Node256 &Node256::New(ART &art, Node &node) {
 void Node256::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n256 = Node256::Get(art, node);
 
@@ -70,7 +70,7 @@ void Node256::InitializeMerge(ART &art, const ARTFlags &flags) {
 void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n256 = Node256::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -84,7 +84,7 @@ void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node c
 void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n256 = Node256::Get(art, node);
 
 	// free the child and decrease the count
@@ -145,7 +145,7 @@ void Node256::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (children[i].IsSet()) {
-			Node::Vacuum(art, children[i], flags);
+			children[i].Vacuum(art, flags);
 		}
 	}
 }

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

@@ -9,8 +9,8 @@ namespace duckdb {
 
 Node4 &Node4::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_4).New());
-	node.type = (uint8_t)NType::NODE_4;
+	node = Node::GetAllocator(art, NType::NODE_4).New();
+	node.SetType((uint8_t)NType::NODE_4);
 	auto &n4 = Node4::Get(art, node);
 
 	n4.count = 0;
@@ -20,7 +20,7 @@ Node4 &Node4::New(ART &art, Node &node) {
 void Node4::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n4 = Node4::Get(art, node);
 
@@ -57,7 +57,7 @@ void Node4::InitializeMerge(ART &art, const ARTFlags &flags) {
 void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n4 = Node4::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -93,7 +93,7 @@ void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chi
 void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n4 = Node4::Get(art, node);
 
 	idx_t child_pos = 0;
@@ -214,7 +214,7 @@ void Node4::Deserialize(MetaBlockReader &reader) {
 void Node4::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < count; i++) {
-		Node::Vacuum(art, children[i], flags);
+		children[i].Vacuum(art, flags);
 	}
 }
 

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

@@ -9,8 +9,8 @@ namespace duckdb {
 
 Node48 &Node48::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_48).New());
-	node.type = (uint8_t)NType::NODE_48;
+	node = Node::GetAllocator(art, NType::NODE_48).New();
+	node.SetType((uint8_t)NType::NODE_48);
 	auto &n48 = Node48::Get(art, node);
 
 	n48.count = 0;
@@ -29,7 +29,7 @@ Node48 &Node48::New(ART &art, Node &node) {
 void Node48::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n48 = Node48::Get(art, node);
 
@@ -109,7 +109,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n48 = Node48::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -141,7 +141,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n48 = Node48::Get(art, node);
 
 	// free the child and decrease the count
@@ -214,7 +214,7 @@ void Node48::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
-			Node::Vacuum(art, children[child_index[i]], flags);
+			children[child_index[i]].Vacuum(art, flags);
 		}
 	}
 }