duckdb 1.3.4 → 1.4.0

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

@@ -5,38 +5,48 @@
 
 namespace duckdb {
 
-Node256Leaf &Node256Leaf::New(ART &art, Node &node) {
+NodeHandle<Node256Leaf> Node256Leaf::New(ART &art, Node &node) {
 	node = Node::GetAllocator(art, NODE_256_LEAF).New();
 	node.SetMetadata(static_cast<uint8_t>(NODE_256_LEAF));
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
 
-	n256.count = 0;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
+	NodeHandle<Node256Leaf> handle(art, node);
+	auto &n = handle.Get();
+
+	n.count = 0;
+	ValidityMask mask(&n.mask[0], Node256::CAPACITY);
 	mask.SetAllInvalid(CAPACITY);
-	return n256;
+
+	return handle;
 }
 
 void Node256Leaf::InsertByte(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
-	n256.count++;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
+	NodeHandle<Node256Leaf> handle(art, node);
+	auto &n = handle.Get();
+
+	n.count++;
+	ValidityMask mask(&n.mask[0], Node256::CAPACITY);
 	mask.SetValid(byte);
 }
 
 void Node256Leaf::DeleteByte(ART &art, Node &node, const uint8_t byte) {
-	auto &n256 = Node::Ref<Node256Leaf>(art, node, NODE_256_LEAF);
-	n256.count--;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	mask.SetInvalid(byte);
-
-	// Shrink node to Node15
-	if (n256.count <= Node48::SHRINK_THRESHOLD) {
-		auto node256 = node;
-		Node15Leaf::ShrinkNode256Leaf(art, node, node256);
+	{
+		NodeHandle<Node256Leaf> handle(art, node);
+		auto &n = handle.Get();
+
+		n.count--;
+		ValidityMask mask(&n.mask[0], Node256::CAPACITY);
+		mask.SetInvalid(byte);
+
+		if (n.count > Node48::SHRINK_THRESHOLD) {
+			return;
+		}
 	}
+	// Shrink node to Node15.
+	auto node256 = node;
+	Node15Leaf::ShrinkNode256Leaf(art, node, node256);
 }
 
-bool Node256Leaf::HasByte(uint8_t &byte) {
+bool Node256Leaf::HasByte(const uint8_t byte) {
 	ValidityMask v_mask(&mask[0], Node256::CAPACITY);
 	return v_mask.RowIsValid(byte);
 }
@@ -64,23 +74,26 @@ bool Node256Leaf::GetNextByte(uint8_t &byte) {
 			return true;
 		}
 	}
+
 	return false;
 }
 
-Node256Leaf &Node256Leaf::GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf) {
-	auto &n15 = Node::Ref<Node15Leaf>(art, node15_leaf, NType::NODE_15_LEAF);
-	auto &n256 = New(art, node256_leaf);
-	node256_leaf.SetGateStatus(node15_leaf.GetGateStatus());
+void Node256Leaf::GrowNode15Leaf(ART &art, Node &node256_leaf, Node &node15_leaf) {
+	{
+		NodeHandle<Node15Leaf> n15_handle(art, node15_leaf);
+		auto &n15 = n15_handle.Get();
 
-	n256.count = n15.count;
-	ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
-	for (uint8_t i = 0; i < n15.count; i++) {
-		mask.SetValid(n15.key[i]);
-	}
+		auto n256_handle = New(art, node256_leaf);
+		auto &n256 = n256_handle.Get();
+		node256_leaf.SetGateStatus(node15_leaf.GetGateStatus());
 
-	n15.count = 0;
-	Node::Free(art, node15_leaf);
-	return n256;
+		n256.count = n15.count;
+		ValidityMask mask(&n256.mask[0], Node256::CAPACITY);
+		for (uint8_t i = 0; i < n15.count; i++) {
+			mask.SetValid(n15.key[i]);
+		}
+	}
+	Node::FreeNode(art, node15_leaf);
 }
 
 } // namespace duckdb

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

@@ -5,126 +5,94 @@
 
 namespace duckdb {
 
-Node48 &Node48::New(ART &art, Node &node) {
-	node = Node::GetAllocator(art, NODE_48).New();
-	node.SetMetadata(static_cast<uint8_t>(NODE_48));
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-
-	n48.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		n48.child_index[i] = EMPTY_MARKER;
-	}
-	for (uint8_t i = 0; i < CAPACITY; i++) {
-		n48.children[i].Clear();
-	}
-
-	return n48;
-}
-
-void Node48::Free(ART &art, Node &node) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-	if (!n48.count) {
-		return;
-	}
-
-	Iterator(n48, [&](Node &child) { Node::Free(art, child); });
-}
-
 void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
-
-	// The node is full. Grow to Node256.
-	if (n48.count == CAPACITY) {
-		auto node48 = node;
-		Node256::GrowNode48(art, node, node48);
-		Node256::InsertChild(art, node, byte, child);
-		return;
-	}
-
-	// Still space. Insert the child.
-	uint8_t child_pos = n48.count;
-	if (n48.children[child_pos].HasMetadata()) {
-		// Find an empty position in the node list.
-		child_pos = 0;
-		while (n48.children[child_pos].HasMetadata()) {
-			child_pos++;
+	{
+		NodeHandle<Node48> handle(art, node);
+		auto &n = handle.Get();
+
+		if (n.count != CAPACITY) {
+			// Still space. Insert the child.
+			// Find an empty position in the node list.
+			auto child_pos = n.count;
+			if (n.children[child_pos].HasMetadata()) {
+				child_pos = 0;
+				while (n.children[child_pos].HasMetadata()) {
+					child_pos++;
+				}
+			}
+
+			n.children[child_pos] = child;
+			n.child_index[byte] = child_pos;
+			n.count++;
+			return;
 		}
 	}
 
-	n48.children[child_pos] = child;
-	n48.child_index[byte] = child_pos;
-	n48.count++;
+	// The node is full.
+	// Grow to Node256.
+	auto node48 = node;
+	Node256::GrowNode48(art, node, node48);
+	Node256::InsertChild(art, node, byte, child);
 }
 
 void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-	auto &n48 = Node::Ref<Node48>(art, node, NODE_48);
+	{
+		NodeHandle<Node48> handle(art, node);
+		auto &n = handle.Get();
 
-	// Free the child and decrease the count.
-	Node::Free(art, n48.children[n48.child_index[byte]]);
-	n48.child_index[byte] = EMPTY_MARKER;
-	n48.count--;
+		// Free the child and decrease the count.
+		Node::FreeTree(art, n.children[n.child_index[byte]]);
+		n.child_index[byte] = EMPTY_MARKER;
+		n.count--;
 
-	// Shrink to Node16.
-	if (n48.count < SHRINK_THRESHOLD) {
-		auto node48 = node;
-		Node16::ShrinkNode48(art, node, node48);
+		if (n.count >= SHRINK_THRESHOLD) {
+			return;
+		}
 	}
-}
-
-void Node48::ReplaceChild(const uint8_t byte, const Node child) {
-	D_ASSERT(count >= SHRINK_THRESHOLD);
 
-	auto status = children[child_index[byte]].GetGateStatus();
-	children[child_index[byte]] = child;
-	if (status == GateStatus::GATE_SET && child.HasMetadata()) {
-		children[child_index[byte]].SetGateStatus(status);
-	}
+	// Shrink to Node16.
+	auto node48 = node;
+	Node16::ShrinkNode48(art, node, node48);
 }
 
-Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
-	auto &n16 = Node::Ref<Node16>(art, node16, NType::NODE_16);
-	auto &n48 = New(art, node48);
-	node48.SetGateStatus(node16.GetGateStatus());
+void Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
+	{
+		NodeHandle<Node16> n16_handle(art, node16);
+		auto &n16 = n16_handle.Get();
 
-	n48.count = n16.count;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		n48.child_index[i] = EMPTY_MARKER;
-	}
-	for (uint8_t i = 0; i < n16.count; i++) {
-		n48.child_index[n16.key[i]] = i;
-		n48.children[i] = n16.children[i];
-	}
-	for (uint8_t i = n16.count; i < CAPACITY; i++) {
-		n48.children[i].Clear();
-	}
+		auto n48_handle = New(art, node48);
+		auto &n48 = n48_handle.Get();
+		node48.SetGateStatus(node16.GetGateStatus());
 
-	n16.count = 0;
-	Node::Free(art, node16);
-	return n48;
+		n48.count = n16.count;
+		for (uint8_t i = 0; i < n16.count; i++) {
+			n48.child_index[n16.key[i]] = i;
+			n48.children[i] = n16.children[i];
+		}
+	}
+	Node::FreeNode(art, node16);
 }
 
-Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
-	auto &n48 = New(art, node48);
-	auto &n256 = Node::Ref<Node256>(art, node256, NType::NODE_256);
-	node48.SetGateStatus(node256.GetGateStatus());
-
-	n48.count = 0;
-	for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
-		if (!n256.children[i].HasMetadata()) {
-			n48.child_index[i] = EMPTY_MARKER;
-			continue;
+void Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
+	{
+		auto n48_handle = New(art, node48);
+		auto &n48 = n48_handle.Get();
+		node48.SetGateStatus(node256.GetGateStatus());
+
+		NodeHandle<Node256> n256_handle(art, node256);
+		auto &n256 = n256_handle.Get();
+
+		n48.count = 0;
+		for (uint16_t i = 0; i < Node256::CAPACITY; i++) {
+			if (!n256.children[i].HasMetadata()) {
+				continue;
+			}
+			n48.child_index[i] = n48.count;
+			n48.children[n48.count] = n256.children[i];
+			n48.count++;
 		}
-		n48.child_index[i] = n48.count;
-		n48.children[n48.count] = n256.children[i];
-		n48.count++;
-	}
-	for (uint8_t i = n48.count; i < CAPACITY; i++) {
-		n48.children[i].Clear();
 	}
-
-	n256.count = 0;
-	Node::Free(art, node256);
-	return n48;
+	Node::FreeNode(art, node256);
 }
 
 } // namespace duckdb

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

@@ -53,6 +53,7 @@ PhysicalOperator &ART::CreatePlan(PlanIndexInput &input) {
 	if (op.unbound_expressions.size() > 1) {
 		sort = false;
 	} else if (op.unbound_expressions[0]->return_type.InternalType() == PhysicalType::VARCHAR) {
+		// TODO: also sort VARCHAR
 		sort = false;
 	}
 
@@ -77,7 +78,7 @@ PhysicalOperator &ART::CreatePlan(PlanIndexInput &input) {
 	projections.emplace_back(new_column_types.size() - 1);
 
 	auto &order = planner.Make<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections),
-	                                          op.estimated_cardinality);
+	                                          op.estimated_cardinality, true);
 	order.children.push_back(prev_op);
 	create_idx.children.push_back(order);
 	return create_idx;

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

@@ -31,27 +31,15 @@ Prefix::Prefix(unsafe_unique_ptr<FixedSizeAllocator> &allocator, const Node ptr_
 	in_memory = true;
 }
 
-optional_idx Prefix::GetMismatchWithKey(ART &art, const Node &node, const ARTKey &key, idx_t &depth) {
-	Prefix prefix(art, node);
-	for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
-		if (prefix.data[i] != key[depth]) {
-			return i;
-		}
-		depth++;
-	}
-	return optional_idx::Invalid();
-}
-
 uint8_t Prefix::GetByte(const ART &art, const Node &node, const uint8_t pos) {
 	D_ASSERT(node.GetType() == PREFIX);
 	Prefix prefix(art, node);
 	return prefix.data[pos];
 }
 
-Prefix Prefix::NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset,
-                           const NType type) {
-	node = Node::GetAllocator(art, type).New();
-	node.SetMetadata(static_cast<uint8_t>(type));
+Prefix Prefix::NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset) {
+	node = Node::GetAllocator(art, PREFIX).New();
+	node.SetMetadata(static_cast<uint8_t>(PREFIX));
 
 	Prefix prefix(art, node, true);
 	prefix.data[Count(art)] = count;
@@ -59,6 +47,7 @@ Prefix Prefix::NewInternal(ART &art, Node &node, const data_ptr_t data, const ui
 		D_ASSERT(count);
 		memcpy(prefix.data, data + offset, count);
 	}
+	prefix.ptr->Clear();
 	return prefix;
 }
 
@@ -68,7 +57,7 @@ void Prefix::New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t
 	while (count) {
 		auto min = MinValue(UnsafeNumericCast<idx_t>(Count(art)), count);
 		auto this_count = UnsafeNumericCast<uint8_t>(min);
-		auto prefix = NewInternal(art, ref, key.data, this_count, offset + depth, PREFIX);
+		auto prefix = NewInternal(art, ref, key.data, this_count, offset + depth);
 
 		ref = *prefix.ptr;
 		offset += this_count;
@@ -76,94 +65,35 @@ void Prefix::New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t
 	}
 }
 
-void Prefix::Free(ART &art, Node &node) {
-	Node next;
-
-	while (node.HasMetadata() && node.GetType() == PREFIX) {
-		Prefix prefix(art, node, true);
-		next = *prefix.ptr;
-		Node::GetAllocator(art, PREFIX).Free(node);
-		node = next;
-	}
-
-	Node::Free(art, node);
-	node.Clear();
-}
+void Prefix::Concat(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte,
+                    const GateStatus node4_status) {
+	// We have four situations from which we enter here:
+	// 1: PREFIX (parent) - Node4 (prev_node4) - PREFIX (child) - INLINED_LEAF, or
+	// 2: PREFIX (parent) - Node4 (prev_node4) - INLINED_LEAF (child), or
+	// 3: Node (parent) - Node4 (prev_node4) - PREFIX (child) - INLINED_LEAF, or
+	// 4: Node (parent) - Node4 (prev_node4) - INLINED_LEAF (child).
 
-void Prefix::Concat(ART &art, Node &parent, uint8_t byte, const GateStatus old_status, const Node &child,
-                    const GateStatus status) {
 	D_ASSERT(!parent.IsAnyLeaf());
 	D_ASSERT(child.HasMetadata());
 
-	if (old_status == GateStatus::GATE_SET) {
-		// Concat Node4.
-		D_ASSERT(status == GateStatus::GATE_SET);
-		return ConcatGate(art, parent, byte, child);
-	}
-	if (child.GetGateStatus() == GateStatus::GATE_SET) {
-		// Concat Node4.
-		D_ASSERT(status == GateStatus::GATE_NOT_SET);
-		return ConcatChildIsGate(art, parent, byte, child);
-	}
-
-	if (status == GateStatus::GATE_SET && child.GetType() == NType::LEAF_INLINED) {
-		auto row_id = child.GetRowId();
-		Free(art, parent);
-		Leaf::New(parent, row_id);
+	// The Node4 was a gate.
+	if (node4_status == GateStatus::GATE_SET) {
+		D_ASSERT(parent.GetGateStatus() == GateStatus::GATE_NOT_SET);
+		D_ASSERT(child.GetGateStatus() == GateStatus::GATE_NOT_SET);
+		ConcatNode4WasGate(art, node4, child, byte);
 		return;
 	}
 
-	if (parent.GetType() != PREFIX) {
-		auto prefix = NewInternal(art, parent, &byte, 1, 0, PREFIX);
-		if (child.GetType() == PREFIX) {
-			prefix.Append(art, child);
-		} else {
-			*prefix.ptr = child;
-		}
+	// The child is a gate.
+	if (child.GetGateStatus() == GateStatus::GATE_SET) {
+		D_ASSERT(node4_status == GateStatus::GATE_NOT_SET);
+		ConcatChildIsGate(art, parent, node4, child, byte);
 		return;
 	}
 
-	auto tail = GetTail(art, parent);
-	tail = tail.Append(art, byte);
-
-	if (child.GetType() == PREFIX) {
-		tail.Append(art, child);
-	} else {
-		*tail.ptr = child;
-	}
-}
-
-template <class NODE>
-optional_idx TraverseInternal(ART &art, reference<NODE> &node, const ARTKey &key, idx_t &depth,
-                              const bool is_mutable = false) {
-	D_ASSERT(node.get().HasMetadata());
-	D_ASSERT(node.get().GetType() == NType::PREFIX);
-
-	while (node.get().GetType() == NType::PREFIX) {
-		auto pos = Prefix::GetMismatchWithKey(art, node, key, depth);
-		if (pos.IsValid()) {
-			return pos;
-		}
-
-		Prefix prefix(art, node, is_mutable);
-		node = *prefix.ptr;
-		if (node.get().GetGateStatus() == GateStatus::GATE_SET) {
-			break;
-		}
-	}
-
-	// We return an invalid index, if (and only if) the next node is:
-	// 1. not a prefix, or
-	// 2. a gate.
-	return optional_idx::Invalid();
-}
-
-optional_idx Prefix::Traverse(ART &art, reference<const Node> &node, const ARTKey &key, idx_t &depth) {
-	return TraverseInternal<const Node>(art, node, key, depth);
-}
-
-optional_idx Prefix::TraverseMutable(ART &art, reference<Node> &node, const ARTKey &key, idx_t &depth) {
-	return TraverseInternal<Node>(art, node, key, depth, true);
+	auto inside_gate = parent.GetGateStatus() == GateStatus::GATE_SET;
+	ConcatInternal(art, parent, node4, child, byte, inside_gate);
+	return;
 }
 
 void Prefix::Reduce(ART &art, Node &node, const idx_t pos) {
@@ -173,8 +103,7 @@ void Prefix::Reduce(ART &art, Node &node, const idx_t pos) {
 	Prefix prefix(art, node);
 	if (pos == idx_t(prefix.data[Count(art)] - 1)) {
 		auto next = *prefix.ptr;
-		prefix.ptr->Clear();
-		Node::Free(art, node);
+		Node::FreeNode(art, node);
 		node = next;
 		return;
 	}
@@ -216,7 +145,7 @@ GateStatus Prefix::Split(ART &art, reference<Node> &node, Node &child, const uin
 		// Create a new prefix and
 		// 1. copy the remaining bytes of this prefix.
 		// 2. append remaining prefix nodes.
-		auto new_prefix = NewInternal(art, child, nullptr, 0, 0, PREFIX);
+		auto new_prefix = NewInternal(art, child, nullptr, 0, 0);
 		new_prefix.data[Count(art)] = prefix.data[Count(art)] - pos - 1;
 		memcpy(new_prefix.data, prefix.data + pos + 1, new_prefix.data[Count(art)]);
 
@@ -243,8 +172,7 @@ GateStatus Prefix::Split(ART &art, reference<Node> &node, Node &child, const uin
 	// No bytes left before the split, free this node.
 	if (pos == 0) {
 		auto old_status = node.get().GetGateStatus();
-		prefix.ptr->Clear();
-		Node::Free(art, node);
+		Node::FreeNode(art, node);
 		return old_status;
 	}
 
@@ -305,8 +233,7 @@ void Prefix::TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<Fixed
 		}
 
 		*new_prefix.ptr = *prefix.ptr;
-		prefix.ptr->Clear();
-		Node::Free(art, current_node);
+		Node::FreeNode(art, current_node);
 		current_node = *new_prefix.ptr;
 	}
 
@@ -321,7 +248,7 @@ Prefix Prefix::Append(ART &art, const uint8_t byte) {
 		return *this;
 	}
 
-	auto prefix = NewInternal(art, *ptr, nullptr, 0, 0, PREFIX);
+	auto prefix = NewInternal(art, *ptr, nullptr, 0, 0);
 	return prefix.Append(art, byte);
 }
 
@@ -341,7 +268,7 @@ void Prefix::Append(ART &art, Node other) {
 		}
 
 		*prefix.ptr = *other_prefix.ptr;
-		Node::GetAllocator(art, PREFIX).Free(other);
+		Node::FreeNode(art, other);
 		other = *prefix.ptr;
 	}
 }
@@ -354,43 +281,106 @@ Prefix Prefix::GetTail(ART &art, const Node &node) {
 	return prefix;
 }
 
-void Prefix::ConcatGate(ART &art, Node &parent, uint8_t byte, const Node &child) {
-	D_ASSERT(child.HasMetadata());
-	Node new_prefix = Node();
-
-	// Inside gates, inlined row IDs are not prefixed.
+void Prefix::ConcatInternal(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte,
+                            const bool inside_gate) {
 	if (child.GetType() == NType::LEAF_INLINED) {
-		Leaf::New(new_prefix, child.GetRowId());
+		if (inside_gate) {
+			if (parent.GetType() == NType::PREFIX) {
+				// The parent only contained the Node4, so we can now inline 'all the way up',
+				// and the gate is no longer nested.
+				while (parent.GetType() == NType::PREFIX) {
+					Prefix prefix(art, parent, true);
+					auto temp = *prefix.ptr;
+					Node::FreeNode(art, parent);
+					parent = temp;
+				}
+				parent = child;
+				return;
+			}
+			// The parent is any node inside the gate.
+			// Inside gates, inlined row IDs are not prefixed,
+			// so we directly inline into the previous Node4.
+			node4 = child;
+			return;
+		}
 
-	} else if (child.GetType() == PREFIX) {
-		// At least one more row ID in this gate.
-		auto prefix = NewInternal(art, new_prefix, &byte, 1, 0, PREFIX);
-		prefix.ptr->Clear();
-		prefix.Append(art, child);
-		new_prefix.SetGateStatus(GateStatus::GATE_SET);
+		// Not inside a gate.
+		if (parent.GetType() == NType::PREFIX) {
+			// Append the byte to the prefix, and then inline the child.
+			auto tail = GetTail(art, parent);
+			tail = tail.Append(art, byte);
+			*tail.ptr = child;
+			return;
+		}
 
-	} else {
-		// At least one more row ID in this gate.
-		auto prefix = NewInternal(art, new_prefix, &byte, 1, 0, PREFIX);
+		auto prefix = NewInternal(art, node4, &byte, 1, 0);
 		*prefix.ptr = child;
-		new_prefix.SetGateStatus(GateStatus::GATE_SET);
+		return;
 	}
 
-	if (parent.GetType() != PREFIX) {
-		parent = new_prefix;
+	// The child is not inlined.
+	if (parent.GetType() == NType::PREFIX) {
+		// Append the byte to the prefix.
+		auto tail = GetTail(art, parent);
+		tail = tail.Append(art, byte);
+
+		// Append the child to the prefix.
+		if (child.GetType() == NType::PREFIX) {
+			tail.Append(art, child);
+			return;
+		}
+		*tail.ptr = child;
+		return;
+	}
+
+	// The child is not inlined, and the parent is not a prefix.
+	auto prefix = NewInternal(art, node4, &byte, 1, 0);
+	if (child.GetType() == NType::PREFIX) {
+		prefix.Append(art, child);
+		return;
+	}
+	*prefix.ptr = child;
+}
+
+void Prefix::ConcatNode4WasGate(ART &art, Node &node4, const Node child, uint8_t byte) {
+	D_ASSERT(child.HasMetadata());
+
+	if (child.GetType() == NType::LEAF_INLINED) {
+		// Inside gates, inlined row IDs are not prefixed.
+		// The child is inlined, so we inline into the previous Node4.
+		// There is no longer a nested leaf.
+		node4 = child;
+		return;
+	}
+
+	if (child.GetType() == PREFIX) {
+		// At least one more row ID in this gate and the child is a prefix.
+		// We create a new prefix of length one containing the remaining byte.
+		// Then, we append the child prefix.
+		auto prefix = NewInternal(art, node4, &byte, 1, 0);
+		prefix.ptr->Clear();
+		prefix.Append(art, child);
+		node4.SetGateStatus(GateStatus::GATE_SET);
 		return;
 	}
-	*GetTail(art, parent).ptr = new_prefix;
+	// At least one more row ID in this gate and the child is not a prefix.
+	// We create a new prefix of length one containing the remaining byte.
+	// then, we append the child.
+	auto prefix = NewInternal(art, node4, &byte, 1, 0);
+	*prefix.ptr = child;
+	node4.SetGateStatus(GateStatus::GATE_SET);
 }
 
-void Prefix::ConcatChildIsGate(ART &art, Node &parent, uint8_t byte, const Node &child) {
-	// Create a new prefix and point it to the gate.
+void Prefix::ConcatChildIsGate(ART &art, Node &parent, Node &node4, const Node child, uint8_t byte) {
 	if (parent.GetType() != PREFIX) {
-		auto prefix = NewInternal(art, parent, &byte, 1, 0, PREFIX);
+		// Create a new prefix at the former position of the Node4,
+		// and point it to the gate.
+		auto prefix = NewInternal(art, node4, &byte, 1, 0);
 		*prefix.ptr = child;
 		return;
 	}
 
+	// The parent is a prefix (chain), so we need to append the byte to its tail.
 	auto tail = GetTail(art, parent);
 	tail = tail.Append(art, byte);
 	*tail.ptr = child;