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

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

@@ -2,361 +2,410 @@
 
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/leaf_segment.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/storage/meta_block_writer.hpp"
 
 namespace duckdb {
 
-Leaf &Leaf::New(ART &art, Node &node, const row_t row_id) {
+void Leaf::New(Node &node, const row_t row_id) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::LEAF).New());
-	node.type = (uint8_t)NType::LEAF;
-	auto &leaf = Leaf::Get(art, node);
-
-	// set the fields of the leaf
-	leaf.count = 1;
-	leaf.row_ids.inlined = row_id;
-	return leaf;
+	// we directly inline this row ID into the node pointer
+	D_ASSERT(row_id < MAX_ROW_ID_LOCAL);
+	node.Reset();
+	node.SetType((uint8_t)NType::LEAF_INLINED);
+	node.SetRowId(row_id);
 }
 
-Leaf &Leaf::New(ART &art, Node &node, const row_t *row_ids, const idx_t count) {
+void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t count) {
 
 	D_ASSERT(count > 1);
 
-	node.SetPtr(Node::GetAllocator(art, NType::LEAF).New());
-	node.type = (uint8_t)NType::LEAF;
-	auto &leaf = Leaf::Get(art, node);
+	idx_t copy_count = 0;
+	while (count) {
+		node.get() = Node::GetAllocator(art, NType::LEAF).New();
+		node.get().SetType((uint8_t)NType::LEAF);
 
-	// reset the count to copy the row IDs
-	leaf.count = 0;
-	reference<LeafSegment> segment(LeafSegment::New(art, leaf.row_ids.ptr));
-	for (idx_t i = 0; i < count; i++) {
-		segment = segment.get().Append(art, leaf.count, row_ids[i]);
-	}
+		auto &leaf = Leaf::Get(art, node);
 
-	return leaf;
-}
+		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count);
+		for (idx_t i = 0; i < leaf.count; i++) {
+			leaf.row_ids[i] = row_ids[copy_count + i];
+		}
 
-void Leaf::Free(ART &art, Node &node) {
+		copy_count += leaf.count;
+		count -= leaf.count;
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
-
-	// free leaf segments
-	auto &leaf = Leaf::Get(art, node);
-	if (!leaf.IsInlined()) {
-		Node::Free(art, leaf.row_ids.ptr);
+		node = leaf.ptr;
+		leaf.ptr.Reset();
 	}
 }
 
-void Leaf::InitializeMerge(const ART &art, const idx_t buffer_count) {
+void Leaf::Free(ART &art, Node &node) {
 
-	if (IsInlined()) {
-		return;
-	}
+	D_ASSERT(node.IsSet() && !node.IsSerialized());
+	auto &child = Leaf::Get(art, node).ptr;
+	Node::Free(art, child);
+}
+
+void Leaf::InitializeMerge(ART &art, Node &node, const ARTFlags &flags) {
 
-	reference<LeafSegment> segment(LeafSegment::Get(art, row_ids.ptr));
-	row_ids.ptr.buffer_id += buffer_count;
+	D_ASSERT(node.IsSet() && !node.IsSerialized());
+	D_ASSERT(node.GetType() == NType::LEAF);
 
-	auto ptr = segment.get().next;
-	while (ptr.IsSet()) {
-		segment.get().next.buffer_id += buffer_count;
-		segment = LeafSegment::Get(art, ptr);
-		ptr = segment.get().next;
+	auto &leaf = Leaf::Get(art, node);
+	if (leaf.ptr.IsSet()) {
+		leaf.ptr.InitializeMerge(art, flags);
 	}
 }
 
-void Leaf::Merge(ART &art, Node &other) {
+void Leaf::Merge(ART &art, Node &l_node, Node &r_node) {
 
-	auto &other_leaf = Leaf::Get(art, other);
+	D_ASSERT(l_node.IsSet() && !l_node.IsSerialized());
+	D_ASSERT(r_node.IsSet() && !r_node.IsSerialized());
 
-	// copy inlined row ID
-	if (other_leaf.IsInlined()) {
-		Insert(art, other_leaf.row_ids.inlined);
-		Node::Free(art, other);
+	// copy inlined row ID of r_node
+	if (r_node.GetType() == NType::LEAF_INLINED) {
+		Leaf::Insert(art, l_node, r_node.GetRowId());
+		r_node.Reset();
 		return;
 	}
 
-	// row ID was inlined, move to a new segment
-	if (IsInlined()) {
-		auto row_id = row_ids.inlined;
-		auto &segment = LeafSegment::New(art, row_ids.ptr);
-		segment.row_ids[0] = row_id;
+	// l_node has an inlined row ID, swap and insert
+	if (l_node.GetType() == NType::LEAF_INLINED) {
+		auto row_id = l_node.GetRowId();
+		l_node = r_node;
+		Leaf::Insert(art, l_node, row_id);
+		r_node.Reset();
+		return;
 	}
 
-	// get the first segment to copy to
-	reference<LeafSegment> segment(LeafSegment::Get(art, row_ids.ptr).GetTail(art));
+	D_ASSERT(l_node.GetType() != NType::LEAF_INLINED);
+	D_ASSERT(r_node.GetType() != NType::LEAF_INLINED);
 
-	// initialize loop variables
-	auto other_ptr = other_leaf.row_ids.ptr;
-	auto remaining = other_leaf.count;
+	reference<Node> l_node_ref(l_node);
+	reference<Leaf> l_leaf = Leaf::Get(art, l_node_ref);
 
-	// copy row IDs
-	while (other_ptr.IsSet()) {
-		auto &other_segment = LeafSegment::Get(art, other_ptr);
-		auto copy_count = MinValue(Node::LEAF_SEGMENT_SIZE, remaining);
+	// find a non-full node
+	while (l_leaf.get().count == Node::LEAF_SIZE) {
+		l_node_ref = l_leaf.get().ptr;
 
-		// copy the data
-		for (idx_t i = 0; i < copy_count; i++) {
-			segment = segment.get().Append(art, count, other_segment.row_ids[i]);
+		// the last leaf is full
+		if (!l_leaf.get().ptr.IsSet()) {
+			break;
 		}
-
-		// adjust the loop variables
-		other_ptr = other_segment.next;
-		remaining -= copy_count;
+		l_leaf = Leaf::Get(art, l_node_ref);
 	}
-	D_ASSERT(remaining == 0);
 
-	Node::Free(art, other);
+	// store the last leaf and then append r_node
+	auto last_leaf_node = l_node_ref.get();
+	l_node_ref.get() = r_node;
+	r_node.Reset();
+
+	// append the remaining row IDs of the last leaf node
+	if (last_leaf_node.IsSet()) {
+		// find the tail
+		l_leaf = Leaf::Get(art, l_node_ref);
+		while (l_leaf.get().ptr.IsSet()) {
+			l_leaf = Leaf::Get(art, l_leaf.get().ptr);
+		}
+		// append the row IDs
+		auto &last_leaf = Leaf::Get(art, last_leaf_node);
+		for (idx_t i = 0; i < last_leaf.count; i++) {
+			l_leaf = l_leaf.get().Append(art, last_leaf.row_ids[i]);
+		}
+		Node::GetAllocator(art, NType::LEAF).Free(last_leaf_node);
+	}
 }
 
-void Leaf::Insert(ART &art, const row_t row_id) {
+void Leaf::Insert(ART &art, Node &node, const row_t row_id) {
+
+	D_ASSERT(node.IsSet() && !node.IsSerialized());
 
-	D_ASSERT(count != 0);
-	if (count == 1) {
-		MoveInlinedToSegment(art);
+	if (node.GetType() == NType::LEAF_INLINED) {
+		Leaf::MoveInlinedToLeaf(art, node);
+		Leaf::Insert(art, node, row_id);
+		return;
 	}
 
 	// append to the tail
-	auto &first_segment = LeafSegment::Get(art, row_ids.ptr);
-	auto &tail = first_segment.GetTail(art);
-	tail.Append(art, count, row_id);
+	reference<Leaf> leaf = Leaf::Get(art, node);
+	while (leaf.get().ptr.IsSet()) {
+		if (leaf.get().ptr.IsSerialized()) {
+			leaf.get().ptr.Deserialize(art);
+		}
+		leaf = Leaf::Get(art, leaf.get().ptr);
+	}
+	leaf.get().Append(art, row_id);
 }
 
-void Leaf::Remove(ART &art, const row_t row_id) {
+bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 
-	if (count == 0) {
-		return;
+	D_ASSERT(node.get().IsSet() && !node.get().IsSerialized());
+
+	if (node.get().GetType() == NType::LEAF_INLINED) {
+		if (node.get().GetRowId() == row_id) {
+			return true;
+		}
+		return false;
 	}
 
-	if (IsInlined()) {
-		if (row_ids.inlined == row_id) {
-			count--;
+	reference<Leaf> leaf = Leaf::Get(art, node);
+
+	// inline the remaining row ID
+	if (leaf.get().count == 2) {
+		if (leaf.get().row_ids[0] == row_id || leaf.get().row_ids[1] == row_id) {
+			auto remaining_row_id = leaf.get().row_ids[0] == row_id ? leaf.get().row_ids[1] : leaf.get().row_ids[0];
+			Node::Free(art, node);
+			Leaf::New(node, remaining_row_id);
 		}
-		return;
+		return false;
 	}
 
-	// possibly inline the row ID
-	if (count == 2) {
-		auto &segment = LeafSegment::Get(art, row_ids.ptr);
-		D_ASSERT(segment.row_ids[0] == row_id || segment.row_ids[1] == row_id);
-		auto remaining_row_id = segment.row_ids[0] == row_id ? segment.row_ids[1] : segment.row_ids[0];
-		Node::Free(art, row_ids.ptr);
-		row_ids.inlined = remaining_row_id;
-		count--;
-		return;
+	// get the last row ID (the order within a leaf does not matter)
+	// because we want to overwrite the row ID to remove with that one
+
+	// go to the tail and keep track of the previous leaf node
+	reference<Leaf> prev_leaf(leaf);
+	while (leaf.get().ptr.IsSet()) {
+		prev_leaf = leaf;
+		if (leaf.get().ptr.IsSerialized()) {
+			leaf.get().ptr.Deserialize(art);
+		}
+		leaf = Leaf::Get(art, leaf.get().ptr);
 	}
 
-	// find the row ID, and the segment containing that row ID (stored in ptr)
-	auto ptr = row_ids.ptr;
-	auto copy_idx = FindRowId(art, ptr, row_id);
-	D_ASSERT(copy_idx != (uint32_t)DConstants::INVALID_INDEX);
-	copy_idx++;
-
-	// iterate all remaining segments and move the row IDs one field to the left
-	reference<LeafSegment> segment(LeafSegment::Get(art, ptr));
-	reference<LeafSegment> prev_segment(LeafSegment::Get(art, ptr));
-	while (copy_idx < count) {
-
-		auto copy_start = copy_idx % Node::LEAF_SEGMENT_SIZE;
-		D_ASSERT(copy_start != 0);
-		auto copy_end = MinValue(copy_start + count - copy_idx, Node::LEAF_SEGMENT_SIZE);
-
-		// copy row IDs
-		for (idx_t i = copy_start; i < copy_end; i++) {
-			segment.get().row_ids[i - 1] = segment.get().row_ids[i];
-			copy_idx++;
+	auto last_idx = leaf.get().count;
+	auto last_row_id = leaf.get().row_ids[last_idx - 1];
+
+	// only one row ID in this leaf segment, free it
+	if (leaf.get().count == 1) {
+		Node::Free(art, prev_leaf.get().ptr);
+		if (last_row_id == row_id) {
+			return false;
 		}
+	} else {
+		leaf.get().count--;
+	}
 
-		// adjust loop variables
-		if (segment.get().next.IsSet()) {
-			prev_segment = segment;
-			segment = LeafSegment::Get(art, segment.get().next);
-			// this segment has at least one element, and we need to copy it into the previous segment
-			prev_segment.get().row_ids[Node::LEAF_SEGMENT_SIZE - 1] = segment.get().row_ids[0];
-			copy_idx++;
+	// find the row ID and copy the last row ID to that position
+	while (node.get().IsSet()) {
+		D_ASSERT(!node.get().IsSerialized());
+		leaf = Leaf::Get(art, node);
+		for (idx_t i = 0; i < leaf.get().count; i++) {
+			if (leaf.get().row_ids[i] == row_id) {
+				leaf.get().row_ids[i] = last_row_id;
+				return false;
+			}
 		}
+		node = leaf.get().ptr;
 	}
+	return false;
+}
 
-	// this evaluates to true, if we need to delete the last segment
-	if (count % Node::LEAF_SEGMENT_SIZE == 1) {
-		ptr = row_ids.ptr;
-		while (ptr.IsSet()) {
+idx_t Leaf::TotalCount(ART &art, Node &node) {
 
-			// get the segment succeeding the current segment
-			auto &current_segment = LeafSegment::Get(art, ptr);
-			D_ASSERT(current_segment.next.IsSet());
-			auto &next_segment = LeafSegment::Get(art, current_segment.next);
+	// NOTE: first leaf in the leaf chain is already deserialized
+	D_ASSERT(node.IsSet() && !node.IsSerialized());
 
-			// next_segment is the tail of the segment list
-			if (!next_segment.next.IsSet()) {
-				Node::Free(art, current_segment.next);
-			}
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return 1;
+	}
 
-			// adjust loop variables
-			ptr = current_segment.next;
+	idx_t count = 0;
+	reference<Node> node_ref(node);
+	while (node_ref.get().IsSet()) {
+		auto &leaf = Leaf::Get(art, node_ref);
+		count += leaf.count;
+
+		if (leaf.ptr.IsSerialized()) {
+			leaf.ptr.Deserialize(art);
 		}
+		node_ref = leaf.ptr;
 	}
-	count--;
+	return count;
 }
 
-row_t Leaf::GetRowId(const ART &art, const idx_t position) const {
+bool Leaf::GetRowIds(ART &art, Node &node, vector<row_t> &result_ids, idx_t max_count) {
 
-	D_ASSERT(position < count);
-	if (IsInlined()) {
-		return row_ids.inlined;
+	// adding more elements would exceed the maximum count
+	D_ASSERT(node.IsSet());
+	if (result_ids.size() + Leaf::TotalCount(art, node) > max_count) {
+		return false;
 	}
 
-	// get the correct segment
-	reference<LeafSegment> segment(LeafSegment::Get(art, row_ids.ptr));
-	for (idx_t i = 0; i < position / Node::LEAF_SEGMENT_SIZE; i++) {
-		D_ASSERT(segment.get().next.IsSet());
-		segment = LeafSegment::Get(art, segment.get().next);
+	// NOTE: Leaf::TotalCount fully deserializes the leaf
+	D_ASSERT(!node.IsSerialized());
+
+	if (node.GetType() == NType::LEAF_INLINED) {
+		// push back the inlined row ID of this leaf
+		result_ids.push_back(node.GetRowId());
+
+	} else {
+		// push back all the row IDs of this leaf
+		reference<Node> last_leaf_ref(node);
+		while (last_leaf_ref.get().IsSet()) {
+			auto &leaf = Leaf::Get(art, last_leaf_ref);
+			for (idx_t i = 0; i < leaf.count; i++) {
+				result_ids.push_back(leaf.row_ids[i]);
+			}
+
+			D_ASSERT(!leaf.ptr.IsSerialized());
+			last_leaf_ref = leaf.ptr;
+		}
 	}
 
-	return segment.get().row_ids[position % Node::LEAF_SEGMENT_SIZE];
+	return true;
 }
 
-uint32_t Leaf::FindRowId(const ART &art, Node &ptr, const row_t row_id) const {
-
-	D_ASSERT(!IsInlined());
+bool Leaf::ContainsRowId(ART &art, Node &node, const row_t row_id) {
 
-	auto remaining = count;
-	while (ptr.IsSet()) {
+	// NOTE: we either just removed a row ID from this leaf (by copying the
+	// last row ID at a different position) or inserted a row ID into this leaf
+	// (at the end), so the whole leaf is deserialized
+	D_ASSERT(node.IsSet() && !node.IsSerialized());
 
-		auto &segment = LeafSegment::Get(art, ptr);
-		auto search_count = MinValue(Node::LEAF_SEGMENT_SIZE, remaining);
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return node.GetRowId() == row_id;
+	}
 
-		// search in this segment
-		for (idx_t i = 0; i < search_count; i++) {
-			if (segment.row_ids[i] == row_id) {
-				return count - remaining + i;
+	reference<Node> ref_node(node);
+	while (ref_node.get().IsSet()) {
+		auto &leaf = Leaf::Get(art, ref_node);
+		for (idx_t i = 0; i < leaf.count; i++) {
+			if (leaf.row_ids[i] == row_id) {
+				return true;
 			}
 		}
 
-		// adjust loop variables
-		remaining -= search_count;
-		ptr = segment.next;
+		D_ASSERT(!leaf.ptr.IsSerialized());
+		ref_node = leaf.ptr;
 	}
-	return (uint32_t)DConstants::INVALID_INDEX;
+
+	return false;
 }
 
-string Leaf::VerifyAndToString(const ART &art, const bool only_verify) const {
+string Leaf::VerifyAndToString(ART &art, Node &node) {
 
-	if (IsInlined()) {
-		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(row_ids.inlined) + "]";
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return "Leaf [count: 1, row ID: " + to_string(node.GetRowId()) + "]";
 	}
 
-	auto ptr = row_ids.ptr;
-	auto remaining = count;
+	// NOTE: we could do this recursively, but the function-call overhead can become kinda crazy
 	string str = "";
-	uint32_t this_count = 0;
-	while (ptr.IsSet()) {
-		auto &segment = LeafSegment::Get(art, ptr);
-		auto to_string_count = Node::LEAF_SEGMENT_SIZE < remaining ? Node::LEAF_SEGMENT_SIZE : remaining;
-
-		for (idx_t i = 0; i < to_string_count; i++) {
-			str += ", " + to_string(segment.row_ids[i]);
-			this_count++;
+
+	reference<Node> node_ref(node);
+	while (node_ref.get().IsSet()) {
+
+		auto &leaf = Leaf::Get(art, node_ref);
+		D_ASSERT(leaf.count <= Node::LEAF_SIZE);
+
+		str += "Leaf [count: " + to_string(leaf.count) + ", row IDs: ";
+		for (idx_t i = 0; i < leaf.count; i++) {
+			str += to_string(leaf.row_ids[i]) + "-";
 		}
-		remaining -= to_string_count;
-		ptr = segment.next;
-	}
+		str += "] ";
 
-	D_ASSERT(remaining == 0);
-	(void)this_count;
-	D_ASSERT(this_count == count);
-	return only_verify ? "" : "Leaf [count: " + to_string(count) + ", row IDs: " + str + "] \n";
+		// NOTE: we are currently only calling this function during CREATE INDEX
+		// statements (and debugging), so the index is never serialized
+		D_ASSERT(!leaf.ptr.IsSerialized());
+		node_ref = leaf.ptr;
+	}
+	return str;
 }
 
-BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
-
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::LEAF);
-	writer.Write<uint32_t>(count);
+BlockPointer Leaf::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
 
-	if (IsInlined()) {
-		writer.Write(row_ids.inlined);
+	if (node.GetType() == NType::LEAF_INLINED) {
+		auto block_pointer = writer.GetBlockPointer();
+		writer.Write(NType::LEAF_INLINED);
+		writer.Write(node.GetRowId());
 		return block_pointer;
 	}
 
-	D_ASSERT(row_ids.ptr.IsSet());
-	auto ptr = row_ids.ptr;
-	auto remaining = count;
-
-	// iterate all leaf segments and write their row IDs
-	while (ptr.IsSet()) {
-		auto &segment = LeafSegment::Get(art, ptr);
-		auto write_count = MinValue(Node::LEAF_SEGMENT_SIZE, remaining);
+	// recurse into the child and retrieve its block pointer
+	auto &leaf = Leaf::Get(art, node);
+	auto child_block_pointer = leaf.ptr.Serialize(art, writer);
 
-		// write the row IDs
-		for (idx_t i = 0; i < write_count; i++) {
-			writer.Write(segment.row_ids[i]);
-		}
+	// get pointer and write fields
+	auto block_pointer = writer.GetBlockPointer();
+	writer.Write(NType::LEAF);
+	writer.Write<uint8_t>(leaf.count);
 
-		// adjust loop variables
-		remaining -= write_count;
-		ptr = segment.next;
+	// write row IDs
+	for (idx_t i = 0; i < leaf.count; i++) {
+		writer.Write(leaf.row_ids[i]);
 	}
-	D_ASSERT(remaining == 0);
+
+	// write child block pointer
+	writer.Write(child_block_pointer.block_id);
+	writer.Write(child_block_pointer.offset);
 
 	return block_pointer;
 }
 
-void Leaf::Deserialize(ART &art, MetaBlockReader &reader) {
+void Leaf::Deserialize(ART &art, Node &node, MetaBlockReader &reader) {
 
-	auto count_p = reader.Read<uint32_t>();
+	D_ASSERT(node.GetType() == NType::LEAF);
 
-	// inlined
-	if (count_p == 1) {
-		row_ids.inlined = reader.Read<row_t>();
-		count = count_p;
-		return;
-	}
+	auto &leaf = Leaf::Get(art, node);
+	leaf.count = reader.Read<uint8_t>();
 
-	// copy into segments
-	count = 0;
-	reference<LeafSegment> segment(LeafSegment::New(art, row_ids.ptr));
-	for (idx_t i = 0; i < count_p; i++) {
-		segment = segment.get().Append(art, count, reader.Read<row_t>());
+	// read row IDs
+	for (idx_t i = 0; i < leaf.count; i++) {
+		leaf.row_ids[i] = reader.Read<row_t>();
 	}
-	D_ASSERT(count_p == count);
-}
 
-void Leaf::Vacuum(ART &art) {
+	// read child block pointer
+	leaf.ptr = Node(reader);
+}
 
-	if (IsInlined()) {
-		return;
-	}
+void Leaf::Vacuum(ART &art, Node &node) {
 
-	// first pointer has special treatment because we don't obtain it from a leaf segment
-	auto &allocator = Node::GetAllocator(art, NType::LEAF_SEGMENT);
-	if (allocator.NeedsVacuum(row_ids.ptr)) {
-		row_ids.ptr.SetPtr(allocator.VacuumPointer(row_ids.ptr));
-		row_ids.ptr.type = (uint8_t)NType::LEAF_SEGMENT;
-	}
+	// NOTE: we could do this recursively, but the function-call overhead can become kinda crazy
+	auto &allocator = Node::GetAllocator(art, NType::LEAF);
 
-	auto ptr = row_ids.ptr;
-	while (ptr.IsSet()) {
-		auto &segment = LeafSegment::Get(art, ptr);
-		ptr = segment.next;
-		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
-			segment.next.SetPtr(allocator.VacuumPointer(ptr));
-			segment.next.type = (uint8_t)NType::LEAF_SEGMENT;
-			ptr = segment.next;
+	reference<Node> node_ref(node);
+	while (node_ref.get().IsSet() && !node_ref.get().IsSerialized()) {
+		if (allocator.NeedsVacuum(node_ref)) {
+			node_ref.get() = allocator.VacuumPointer(node_ref);
+			node_ref.get().SetType((uint8_t)NType::LEAF);
 		}
+		auto &leaf = Leaf::Get(art, node_ref);
+		node_ref = leaf.ptr;
 	}
+	return;
+}
+
+void Leaf::MoveInlinedToLeaf(ART &art, Node &node) {
+
+	D_ASSERT(node.GetType() == NType::LEAF_INLINED);
+	auto row_id = node.GetRowId();
+	node = Node::GetAllocator(art, NType::LEAF).New();
+	node.SetType((uint8_t)NType::LEAF);
+
+	auto &leaf = Leaf::Get(art, node);
+	leaf.count = 1;
+	leaf.row_ids[0] = row_id;
+	leaf.ptr.Reset();
 }
 
-void Leaf::MoveInlinedToSegment(ART &art) {
+Leaf &Leaf::Append(ART &art, const row_t row_id) {
+
+	reference<Leaf> leaf(*this);
 
-	D_ASSERT(IsInlined());
+	// we need a new leaf node
+	if (leaf.get().count == Node::LEAF_SIZE) {
+		leaf.get().ptr = Node::GetAllocator(art, NType::LEAF).New();
+		leaf.get().ptr.SetType((uint8_t)NType::LEAF);
+
+		leaf = Leaf::Get(art, leaf.get().ptr);
+		leaf.get().count = 0;
+		leaf.get().ptr.Reset();
+	}
 
-	auto row_id = row_ids.inlined;
-	auto &segment = LeafSegment::New(art, row_ids.ptr);
-	segment.row_ids[0] = row_id;
+	leaf.get().row_ids[leaf.get().count] = row_id;
+	leaf.get().count++;
+	return leaf.get();
 }
 
 } // namespace duckdb