duckdb 1.3.4 → 1.4.0

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

@@ -30,8 +30,10 @@ void BaseNode<CAPACITY, TYPE>::InsertChildInternal(BaseNode &n, const uint8_t by
 }
 
 template <uint8_t CAPACITY, NType TYPE>
-BaseNode<CAPACITY, TYPE> &BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art, Node &node, const uint8_t byte) {
-	auto &n = Node::Ref<BaseNode>(art, node, TYPE);
+NodeHandle<BaseNode<CAPACITY, TYPE>> BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art, Node &node,
+                                                                                   const uint8_t byte) {
+	NodeHandle<BaseNode<CAPACITY, TYPE>> handle(art, node);
+	auto &n = handle.Get();
 
 	uint8_t child_pos = 0;
 	for (; child_pos < n.count; child_pos++) {
@@ -41,7 +43,7 @@ BaseNode<CAPACITY, TYPE> &BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art
 	}
 
 	// Free the child and decrease the count.
-	Node::Free(art, n.children[child_pos]);
+	Node::FreeTree(art, n.children[child_pos]);
 	n.count--;
 
 	// Possibly move children backwards.
@@ -49,7 +51,8 @@ BaseNode<CAPACITY, TYPE> &BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art
 		n.key[i] = n.key[i + 1];
 		n.children[i] = n.children[i + 1];
 	}
-	return n;
+
+	return handle;
 }
 
 //===--------------------------------------------------------------------===//
@@ -57,107 +60,132 @@ BaseNode<CAPACITY, TYPE> &BaseNode<CAPACITY, TYPE>::DeleteChildInternal(ART &art
 //===--------------------------------------------------------------------===//
 
 void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	// The node is full. Grow to Node16.
-	auto &n = Node::Ref<Node4>(art, node, NODE_4);
-	if (n.count == CAPACITY) {
-		auto node4 = node;
-		Node16::GrowNode4(art, node, node4);
-		Node16::InsertChild(art, node, byte, child);
-		return;
-	}
+	{
+		NodeHandle<Node4> handle(art, node);
+		auto &n = handle.Get();
 
-	InsertChildInternal(n, byte, child);
+		if (n.count != CAPACITY) {
+			InsertChildInternal(n, byte, child);
+			return;
+		}
+	}
+	// The node is full.
+	// Grow to Node16.
+	auto node4 = node;
+	Node16::GrowNode4(art, node, node4);
+	Node16::InsertChild(art, node, byte, child);
 }
 
-void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status) {
-	auto &n = DeleteChildInternal(art, node, byte);
+void Node4::DeleteChild(ART &art, Node &node, Node &parent, const uint8_t byte, const GateStatus status) {
+	Node child;
+	uint8_t remaining_byte;
 
-	// Compress one-way nodes.
-	if (n.count == 1) {
-		n.count--;
+	{
+		auto handle = DeleteChildInternal(art, node, byte);
+		auto &n = handle.Get();
 
-		auto child = n.children[0];
-		auto remainder = n.key[0];
-		auto old_status = node.GetGateStatus();
+		if (n.count != 1) {
+			return;
+		}
 
-		Node::Free(art, node);
-		Prefix::Concat(art, prefix, remainder, old_status, child, status);
+		// Compress one-way nodes.
+		child = n.children[0];
+		remaining_byte = n.key[0];
 	}
+
+	auto prev_node4_status = node.GetGateStatus();
+	Node::FreeNode(art, node);
+	Prefix::Concat(art, parent, node, child, remaining_byte, prev_node4_status);
 }
 
 void Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
-	auto &n4 = New(art, node4);
-	auto &n16 = Node::Ref<Node16>(art, node16, NType::NODE_16);
-	node4.SetGateStatus(node16.GetGateStatus());
-
-	n4.count = n16.count;
-	for (uint8_t i = 0; i < n16.count; i++) {
-		n4.key[i] = n16.key[i];
-		n4.children[i] = n16.children[i];
+	{
+		auto n4_handle = New(art, node4);
+		auto &n4 = n4_handle.Get();
+		node4.SetGateStatus(node16.GetGateStatus());
+
+		NodeHandle<Node16> n16_handle(art, node16);
+		auto &n16 = n16_handle.Get();
+
+		n4.count = n16.count;
+		for (uint8_t i = 0; i < n16.count; i++) {
+			n4.key[i] = n16.key[i];
+			n4.children[i] = n16.children[i];
+		}
 	}
-
-	n16.count = 0;
-	Node::Free(art, node16);
+	Node::FreeNode(art, node16);
 }
 
 //===--------------------------------------------------------------------===//
 // Node16
 //===--------------------------------------------------------------------===//
 
-void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n = DeleteChildInternal(art, node, byte);
-
-	// Shrink node to Node4.
-	if (n.count < Node4::CAPACITY) {
-		auto node16 = node;
-		Node4::ShrinkNode16(art, node, node16);
+void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
+	{
+		NodeHandle<Node16> handle(art, node);
+		auto &n = handle.Get();
+		if (n.count != CAPACITY) {
+			InsertChildInternal(n, byte, child);
+			return;
+		}
 	}
+	// The node is full.
+	// Grow to Node48.
+	auto node16 = node;
+	Node48::GrowNode16(art, node, node16);
+	Node48::InsertChild(art, node, byte, child);
 }
 
-void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	// The node is full. Grow to Node48.
-	auto &n16 = Node::Ref<Node16>(art, node, NODE_16);
-	if (n16.count == CAPACITY) {
-		auto node16 = node;
-		Node48::GrowNode16(art, node, node16);
-		Node48::InsertChild(art, node, byte, child);
-		return;
+void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+	{
+		auto handle = DeleteChildInternal(art, node, byte);
+		auto &n = handle.Get();
+		if (n.count >= Node4::CAPACITY) {
+			return;
+		}
 	}
-
-	InsertChildInternal(n16, byte, child);
+	// Shrink node to Node4.
+	auto node16 = node;
+	Node4::ShrinkNode16(art, node, node16);
 }
 
 void Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
-	auto &n4 = Node::Ref<Node4>(art, node4, NType::NODE_4);
-	auto &n16 = New(art, node16);
-	node16.SetGateStatus(node4.GetGateStatus());
-
-	n16.count = n4.count;
-	for (uint8_t i = 0; i < n4.count; i++) {
-		n16.key[i] = n4.key[i];
-		n16.children[i] = n4.children[i];
+	{
+		NodeHandle<Node4> n4_handle(art, node4);
+		auto &n4 = n4_handle.Get();
+
+		auto n16_handle = New(art, node16);
+		auto &n16 = n16_handle.Get();
+		node16.SetGateStatus(node4.GetGateStatus());
+
+		n16.count = n4.count;
+		for (uint8_t i = 0; i < n4.count; i++) {
+			n16.key[i] = n4.key[i];
+			n16.children[i] = n4.children[i];
+		}
 	}
-
-	n4.count = 0;
-	Node::Free(art, node4);
+	Node::FreeNode(art, node4);
 }
 
 void Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
-	auto &n16 = New(art, node16);
-	auto &n48 = Node::Ref<Node48>(art, node48, NType::NODE_48);
-	node16.SetGateStatus(node48.GetGateStatus());
-
-	n16.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		if (n48.child_index[i] != Node48::EMPTY_MARKER) {
-			n16.key[n16.count] = UnsafeNumericCast<uint8_t>(i);
-			n16.children[n16.count] = n48.children[n48.child_index[i]];
-			n16.count++;
+	{
+		auto n16_handle = New(art, node16);
+		auto &n16 = n16_handle.Get();
+		node16.SetGateStatus(node48.GetGateStatus());
+
+		NodeHandle<Node48> n48_handle(art, node48);
+		auto &n48 = n48_handle.Get();
+
+		n16.count = 0;
+		for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
+			if (n48.child_index[i] != Node48::EMPTY_MARKER) {
+				n16.key[n16.count] = UnsafeNumericCast<uint8_t>(i);
+				n16.children[n16.count] = n48.children[n48.child_index[i]];
+				n16.count++;
+			}
 		}
 	}
-
-	n48.count = 0;
-	Node::Free(art, node48);
+	Node::FreeNode(art, node48);
 }
 
 } // namespace duckdb

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

@@ -42,7 +42,7 @@ bool IteratorKey::GreaterThan(const ARTKey &key, const bool equal, const uint8_t
 // Iterator
 //===--------------------------------------------------------------------===//
 
-bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vector<row_t> &row_ids, const bool equal) {
+bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, set<row_t> &row_ids, const bool equal) {
 	bool has_next;
 	do {
 		// An empty upper bound indicates that no upper bound exists.
@@ -59,7 +59,7 @@ bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vec
 			if (row_ids.size() + 1 > max_count) {
 				return false;
 			}
-			row_ids.push_back(last_leaf.GetRowId());
+			row_ids.insert(last_leaf.GetRowId());
 			break;
 		case NType::LEAF:
 			if (!Leaf::DeprecatedGetRowIds(art, last_leaf, row_ids, max_count)) {
@@ -76,7 +76,7 @@ bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vec
 				}
 				row_id[ROW_ID_SIZE - 1] = byte;
 				ARTKey key(&row_id[0], ROW_ID_SIZE);
-				row_ids.push_back(key.GetRowId());
+				row_ids.insert(key.GetRowId());
 				if (byte == NumericLimits<uint8_t>::Maximum()) {
 					break;
 				}

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

@@ -98,7 +98,7 @@ void Leaf::TransformToNested(ART &art, Node &node) {
 	}
 
 	root.SetGateStatus(GateStatus::GATE_SET);
-	Node::Free(art, node);
+	DeprecatedFree(art, node);
 	node = root;
 }
 
@@ -111,17 +111,17 @@ void Leaf::TransformToDeprecated(ART &art, Node &node) {
 	}
 
 	// Collect all row IDs and free the nested leaf.
-	unsafe_vector<row_t> row_ids;
+	set<row_t> row_ids;
 	Iterator it(art);
 	it.FindMinimum(node);
 	ARTKey empty_key = ARTKey();
 	it.Scan(empty_key, NumericLimits<row_t>().Maximum(), row_ids, false);
-	Node::Free(art, node);
+	Node::FreeTree(art, node);
 	D_ASSERT(row_ids.size() > 1);
 
 	// Create the deprecated leaves.
 	idx_t remaining = row_ids.size();
-	idx_t copy_count = 0;
+	auto row_ids_it = row_ids.begin();
 	reference<Node> ref(node);
 	while (remaining) {
 		ref.get() = Node::GetAllocator(art, LEAF).New();
@@ -132,10 +132,9 @@ void Leaf::TransformToDeprecated(ART &art, Node &node) {
 		leaf.count = UnsafeNumericCast<uint8_t>(min);
 
 		for (uint8_t i = 0; i < leaf.count; i++) {
-			leaf.row_ids[i] = row_ids[copy_count + i];
+			leaf.row_ids[i] = *row_ids_it;
+			row_ids_it++;
 		}
-
-		copy_count += leaf.count;
 		remaining -= leaf.count;
 
 		ref = leaf.ptr;
@@ -149,17 +148,16 @@ void Leaf::TransformToDeprecated(ART &art, Node &node) {
 
 void Leaf::DeprecatedFree(ART &art, Node &node) {
 	D_ASSERT(node.GetType() == LEAF);
-
 	Node next;
 	while (node.HasMetadata()) {
 		next = Node::Ref<Leaf>(art, node, LEAF).ptr;
-		Node::GetAllocator(art, LEAF).Free(node);
+		Node::FreeNode(art, node);
 		node = next;
 	}
 	node.Clear();
 }
 
-bool Leaf::DeprecatedGetRowIds(ART &art, const Node &node, unsafe_vector<row_t> &row_ids, const idx_t max_count) {
+bool Leaf::DeprecatedGetRowIds(ART &art, const Node &node, set<row_t> &row_ids, const idx_t max_count) {
 	D_ASSERT(node.GetType() == LEAF);
 
 	reference<const Node> ref(node);
@@ -170,7 +168,7 @@ bool Leaf::DeprecatedGetRowIds(ART &art, const Node &node, unsafe_vector<row_t>
 			return false;
 		}
 		for (uint8_t i = 0; i < leaf.count; i++) {
-			row_ids.push_back(leaf.row_ids[i]);
+			row_ids.insert(leaf.row_ids[i]);
 		}
 		ref = leaf.ptr;
 	}

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

@@ -44,44 +44,45 @@ void Node::New(ART &art, Node &node, NType type) {
 		Node256::New(art, node);
 		break;
 	default:
-		throw InternalException("Invalid node type for New: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for New: %d.", type);
 	}
 }
 
-void Node::Free(ART &art, Node &node) {
-	if (!node.HasMetadata()) {
-		return node.Clear();
-	}
+void Node::FreeNode(ART &art, Node &node) {
+	D_ASSERT(node.HasMetadata());
+	GetAllocator(art, node.GetType()).Free(node);
+	node.Clear();
+}
 
-	// Free the children.
-	auto type = node.GetType();
-	switch (type) {
-	case NType::PREFIX:
-		return Prefix::Free(art, node);
-	case NType::LEAF:
-		return Leaf::DeprecatedFree(art, node);
-	case NType::NODE_4:
-		Node4::Free(art, node);
-		break;
-	case NType::NODE_16:
-		Node16::Free(art, node);
-		break;
-	case NType::NODE_48:
-		Node48::Free(art, node);
-		break;
-	case NType::NODE_256:
-		Node256::Free(art, node);
-		break;
-	case NType::LEAF_INLINED:
-		return node.Clear();
-	case NType::NODE_7_LEAF:
-	case NType::NODE_15_LEAF:
-	case NType::NODE_256_LEAF:
-		break;
-	}
+void Node::FreeTree(ART &art, Node &node) {
+	auto handler = [&art](Node &node) {
+		const auto type = node.GetType();
+		switch (type) {
+		case NType::LEAF_INLINED:
+			node.Clear();
+			return ARTHandlingResult::NONE;
+		case NType::LEAF:
+			Leaf::DeprecatedFree(art, node);
+			return ARTHandlingResult::NONE;
+		case NType::NODE_7_LEAF:
+		case NType::NODE_15_LEAF:
+		case NType::NODE_256_LEAF:
+		case NType::PREFIX:
+		case NType::NODE_4:
+		case NType::NODE_16:
+		case NType::NODE_48:
+		case NType::NODE_256:
+			break;
+		default:
+			throw InternalException("invalid node type for Free: %d", type);
+		}
 
-	GetAllocator(art, type).Free(node);
-	node.Clear();
+		FreeNode(art, node);
+		return ARTHandlingResult::NONE;
+	};
+
+	ARTScanner<ARTScanHandling::POP, Node> scanner(art, handler, node);
+	scanner.Scan(handler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -113,7 +114,7 @@ uint8_t Node::GetAllocatorIdx(const NType type) {
 	case NType::NODE_256_LEAF:
 		return 8;
 	default:
-		throw InternalException("Invalid node type for GetAllocatorIdx: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetAllocatorIdx: %d.", type);
 	}
 }
 
@@ -135,7 +136,7 @@ void Node::ReplaceChild(const ART &art, const uint8_t byte, const Node child) co
 	case NType::NODE_256:
 		return Ref<Node256>(art, *this, type).ReplaceChild(byte, child);
 	default:
-		throw InternalException("Invalid node type for ReplaceChild: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for ReplaceChild: %d.", type);
 	}
 }
 
@@ -159,7 +160,7 @@ void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chil
 	case NType::NODE_256_LEAF:
 		return Node256Leaf::InsertByte(art, node, byte);
 	default:
-		throw InternalException("Invalid node type for InsertChild: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for InsertChild: %d.", type);
 	}
 }
 
@@ -188,7 +189,7 @@ void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, c
 	case NType::NODE_256_LEAF:
 		return Node256Leaf::DeleteByte(art, node, byte);
 	default:
-		throw InternalException("Invalid node type for DeleteChild: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for DeleteChild: %d.", type);
 	}
 }
 
@@ -197,31 +198,31 @@ void Node::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, c
 //===--------------------------------------------------------------------===//
 
 template <class NODE>
-unsafe_optional_ptr<Node> GetChildInternal(ART &art, NODE &node, const uint8_t byte) {
+static unsafe_optional_ptr<Node> GetChildInternal(ART &art, NODE &node, const uint8_t byte, const bool unsafe) {
 	D_ASSERT(node.HasMetadata());
 
 	auto type = node.GetType();
 	switch (type) {
 	case NType::NODE_4:
-		return Node4::GetChild(Node::Ref<Node4>(art, node, type), byte);
+		return Node4::GetChild(Node::Ref<Node4>(art, node, type), byte, unsafe);
 	case NType::NODE_16:
-		return Node16::GetChild(Node::Ref<Node16>(art, node, type), byte);
+		return Node16::GetChild(Node::Ref<Node16>(art, node, type), byte, unsafe);
 	case NType::NODE_48:
-		return Node48::GetChild(Node::Ref<Node48>(art, node, type), byte);
+		return Node48::GetChild(Node::Ref<Node48>(art, node, type), byte, unsafe);
 	case NType::NODE_256: {
-		return Node256::GetChild(Node::Ref<Node256>(art, node, type), byte);
+		return Node256::GetChild(Node::Ref<Node256>(art, node, type), byte, unsafe);
 	}
 	default:
-		throw InternalException("Invalid node type for GetChildInternal: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetChildInternal: %d.", type);
 	}
 }
 
 const unsafe_optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
-	return GetChildInternal(art, *this, byte);
+	return GetChildInternal(art, *this, byte, false);
 }
 
-unsafe_optional_ptr<Node> Node::GetChildMutable(ART &art, const uint8_t byte) const {
-	return GetChildInternal(art, *this, byte);
+unsafe_optional_ptr<Node> Node::GetChildMutable(ART &art, const uint8_t byte, const bool unsafe) const {
+	return GetChildInternal(art, *this, byte, unsafe);
 }
 
 template <class NODE>
@@ -239,7 +240,7 @@ unsafe_optional_ptr<Node> GetNextChildInternal(ART &art, NODE &node, uint8_t &by
 	case NType::NODE_256:
 		return Node256::GetNextChild(Node::Ref<Node256>(art, node, type), byte);
 	default:
-		throw InternalException("Invalid node type for GetNextChildInternal: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetNextChildInternal: %d.", type);
 	}
 }
 
@@ -247,7 +248,7 @@ const unsafe_optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte) cons
 	return GetNextChildInternal(art, *this, byte);
 }
 
-bool Node::HasByte(ART &art, uint8_t &byte) const {
+bool Node::HasByte(ART &art, const uint8_t byte) const {
 	D_ASSERT(HasMetadata());
 
 	auto type = GetType();
@@ -259,7 +260,7 @@ bool Node::HasByte(ART &art, uint8_t &byte) const {
 	case NType::NODE_256_LEAF:
 		return Ref<Node256Leaf>(art, *this, NType::NODE_256_LEAF).HasByte(byte);
 	default:
-		throw InternalException("Invalid node type for GetNextByte: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetNextByte: %d.", type);
 	}
 }
 
@@ -275,7 +276,7 @@ bool Node::GetNextByte(ART &art, uint8_t &byte) const {
 	case NType::NODE_256_LEAF:
 		return Ref<Node256Leaf>(art, *this, NType::NODE_256_LEAF).GetNextByte(byte);
 	default:
-		throw InternalException("Invalid node type for GetNextByte: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetNextByte: %d.", type);
 	}
 }
 
@@ -300,7 +301,7 @@ idx_t GetCapacity(NType type) {
 	case NType::NODE_256:
 		return Node256::CAPACITY;
 	default:
-		throw InternalException("Invalid node type for GetCapacity: %s.", EnumUtil::ToString(type));
+		throw InternalException("Invalid node type for GetCapacity: %d.", type);
 	}
 }
 
@@ -382,7 +383,7 @@ void Node::TransformToDeprecated(ART &art, Node &node,
 	case NType::NODE_256:
 		return TransformToDeprecatedInternal(art, InMemoryRef<Node256>(art, node, type), deprecated_prefix_allocator);
 	default:
-		throw InternalException("invalid node type for TransformToDeprecated: %s", EnumUtil::ToString(type));
+		throw InternalException("invalid node type for TransformToDeprecated: %d", type);
 	}
 }
 
@@ -471,7 +472,7 @@ void Node::VerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_count
 			break;
 		}
 		default:
-			throw InternalException("invalid node type for VerifyAllocations: %s", EnumUtil::ToString(type));
+			throw InternalException("invalid node type for VerifyAllocations: %d", type);
 		}
 		node_counts[GetAllocatorIdx(type)]++;
 		return result;

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

@@ -4,75 +4,49 @@
 
 namespace duckdb {
 
-Node256 &Node256::New(ART &art, Node &node) {
-	node = Node::GetAllocator(art, NODE_256).New();
-	node.SetMetadata(static_cast<uint8_t>(NODE_256));
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-
-	n256.count = 0;
-	for (uint16_t i = 0; i < CAPACITY; i++) {
-		n256.children[i].Clear();
-	}
-
-	return n256;
-}
-
-void Node256::Free(ART &art, Node &node) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-	if (!n256.count) {
-		return;
-	}
-
-	Iterator(n256, [&](Node &child) { Node::Free(art, child); });
-}
-
 void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
-	n256.count++;
-	n256.children[byte] = child;
+	NodeHandle<Node256> handle(art, node);
+	auto &n = handle.Get();
+	n.count++;
+	n.children[byte] = child;
 }
 
 void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256>(art, node, NODE_256);
+	{
+		NodeHandle<Node256> handle(art, node);
+		auto &n = handle.Get();
 
-	// Free the child and decrease the count.
-	Node::Free(art, n256.children[byte]);
-	n256.count--;
+		// Free the child and decrease the count.
+		Node::FreeTree(art, n.children[byte]);
+		n.count--;
 
-	// Shrink to Node48.
-	if (n256.count <= SHRINK_THRESHOLD) {
-		auto node256 = node;
-		Node48::ShrinkNode256(art, node, node256);
+		if (n.count > SHRINK_THRESHOLD) {
+			return;
+		}
 	}
-}
-
-void Node256::ReplaceChild(const uint8_t byte, const Node child) {
-	D_ASSERT(count > SHRINK_THRESHOLD);
 
-	auto status = children[byte].GetGateStatus();
-	children[byte] = child;
-	if (status == GateStatus::GATE_SET && child.HasMetadata()) {
-		children[byte].SetGateStatus(status);
-	}
+	// Shrink to Node48.
+	auto node256 = node;
+	Node48::ShrinkNode256(art, node, node256);
 }
 
-Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
-	auto &n48 = Node::Ref<Node48>(art, node48, NType::NODE_48);
-	auto &n256 = New(art, node256);
-	node256.SetGateStatus(node48.GetGateStatus());
+void Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
+	{
+		NodeHandle<Node48> n48_handle(art, node48);
+		auto &n48 = n48_handle.Get();
 
-	n256.count = n48.count;
-	for (uint16_t i = 0; i < CAPACITY; i++) {
-		if (n48.child_index[i] != Node48::EMPTY_MARKER) {
-			n256.children[i] = n48.children[n48.child_index[i]];
-		} else {
-			n256.children[i].Clear();
+		auto n256_handle = New(art, node256);
+		auto &n256 = n256_handle.Get();
+		node256.SetGateStatus(node48.GetGateStatus());
+
+		n256.count = n48.count;
+		for (uint16_t i = 0; i < CAPACITY; i++) {
+			if (n48.child_index[i] != Node48::EMPTY_MARKER) {
+				n256.children[i] = n48.children[n48.child_index[i]];
+			}
 		}
 	}
-
-	n48.count = 0;
-	Node::Free(art, node48);
-	return n256;
+	Node::FreeNode(art, node48);
 }
 
 } // namespace duckdb