duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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

@@ -1,391 +1,347 @@
 #include "duckdb/execution/index/art/leaf.hpp"
 
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/leaf_segment.hpp"
 #include "duckdb/execution/index/art/node.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 ARTKey &key, const uint32_t depth, 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);
+	// we directly inline this row ID into the node pointer
+	D_ASSERT(row_id < MAX_ROW_ID_LOCAL);
+	node.Clear();
+	node.SetMetadata(static_cast<uint8_t>(NType::LEAF_INLINED));
+	node.SetRowId(row_id);
+}
 
-	// set the fields of the leaf
-	leaf.count = 1;
-	leaf.row_ids.inlined = row_id;
+void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t count) {
 
-	// initialize the prefix
-	D_ASSERT(key.len >= depth);
-	leaf.prefix.Initialize(art, key, depth, key.len - depth);
+	D_ASSERT(count > 1);
 
-	return leaf;
-}
+	idx_t copy_count = 0;
+	while (count) {
+		node.get() = Node::GetAllocator(art, NType::LEAF).New();
+		node.get().SetMetadata(static_cast<uint8_t>(NType::LEAF));
 
-Leaf &Leaf::New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t *row_ids,
-                const idx_t count) {
+		auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
-	// inlined leaf
-	D_ASSERT(count >= 1);
-	if (count == 1) {
-		return Leaf::New(art, node, key, depth, row_ids[0]);
-	}
+		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count);
 
-	node.SetPtr(Node::GetAllocator(art, NType::LEAF).New());
-	node.type = (uint8_t)NType::LEAF;
-	auto &leaf = Leaf::Get(art, node);
+		for (idx_t i = 0; i < leaf.count; i++) {
+			leaf.row_ids[i] = row_ids[copy_count + i];
+		}
 
-	// set the fields of the leaf
-	leaf.count = 0;
+		copy_count += leaf.count;
+		count -= leaf.count;
 
-	// copy the row IDs
-	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]);
+		node = leaf.ptr;
+		leaf.ptr.Clear();
 	}
+}
 
-	// set the prefix
-	D_ASSERT(key.len >= depth);
-	leaf.prefix.Initialize(art, key, depth, key.len - depth);
+Leaf &Leaf::New(ART &art, Node &node) {
+	node = Node::GetAllocator(art, NType::LEAF).New();
+	node.SetMetadata(static_cast<uint8_t>(NType::LEAF));
+	auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
+	leaf.count = 0;
+	leaf.ptr.Clear();
 	return leaf;
 }
 
 void Leaf::Free(ART &art, Node &node) {
 
-	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 current_node = node;
+	Node next_node;
+	while (current_node.HasMetadata()) {
+		next_node = Node::RefMutable<Leaf>(art, current_node, NType::LEAF).ptr;
+		Node::GetAllocator(art, NType::LEAF).Free(current_node);
+		current_node = next_node;
 	}
+
+	node.Clear();
 }
 
-void Leaf::InitializeMerge(const ART &art, const idx_t buffer_count) {
+void Leaf::InitializeMerge(ART &art, Node &node, const ARTFlags &flags) {
 
-	if (IsInlined()) {
-		return;
-	}
+	auto merge_buffer_count = flags.merge_buffer_counts[static_cast<uint8_t>(NType::LEAF) - 1];
 
-	reference<LeafSegment> segment(LeafSegment::Get(art, row_ids.ptr));
-	row_ids.ptr.buffer_id += buffer_count;
+	Node next_node = node;
+	node.IncreaseBufferId(merge_buffer_count);
 
-	auto ptr = segment.get().next;
-	while (ptr.IsSet()) {
-		segment.get().next.buffer_id += buffer_count;
-		segment = LeafSegment::Get(art, ptr);
-		ptr = segment.get().next;
+	while (next_node.HasMetadata()) {
+		auto &leaf = Node::RefMutable<Leaf>(art, next_node, NType::LEAF);
+		next_node = leaf.ptr;
+		if (leaf.ptr.HasMetadata()) {
+			leaf.ptr.IncreaseBufferId(merge_buffer_count);
+		}
 	}
 }
 
-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.HasMetadata() && r_node.HasMetadata());
 
-	// 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) {
+		Insert(art, l_node, r_node.GetRowId());
+		r_node.Clear();
 		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;
+		Insert(art, l_node, row_id);
+		r_node.Clear();
+		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 = Node::RefMutable<Leaf>(art, l_node_ref, NType::LEAF);
 
-	// 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.HasMetadata()) {
+			break;
 		}
-
-		// adjust the loop variables
-		other_ptr = other_segment.next;
-		remaining -= copy_count;
+		l_leaf = Node::RefMutable<Leaf>(art, l_node_ref, NType::LEAF);
 	}
-	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.Clear();
+
+	// append the remaining row IDs of the last leaf node
+	if (last_leaf_node.HasMetadata()) {
+		// find the tail
+		l_leaf = Node::RefMutable<Leaf>(art, l_node_ref, NType::LEAF);
+		while (l_leaf.get().ptr.HasMetadata()) {
+			l_leaf = Node::RefMutable<Leaf>(art, l_leaf.get().ptr, NType::LEAF);
+		}
+		// append the row IDs
+		auto &last_leaf = Node::RefMutable<Leaf>(art, last_leaf_node, NType::LEAF);
+		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) {
 
-	if (count == 0) {
-		row_ids.inlined = row_id;
-		count++;
-		return;
-	}
+	D_ASSERT(node.HasMetadata());
 
-	if (count == 1) {
-		MoveInlinedToSegment(art);
+	if (node.GetType() == NType::LEAF_INLINED) {
+		MoveInlinedToLeaf(art, node);
+		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 = Node::RefMutable<Leaf>(art, node, NType::LEAF);
+	while (leaf.get().ptr.HasMetadata()) {
+		leaf = Node::RefMutable<Leaf>(art, leaf.get().ptr, NType::LEAF);
+	}
+	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().HasMetadata());
 
-	if (IsInlined()) {
-		if (row_ids.inlined == row_id) {
-			count--;
+	if (node.get().GetType() == NType::LEAF_INLINED) {
+		if (node.get().GetRowId() == row_id) {
+			return true;
 		}
-		return;
+		return false;
 	}
 
-	// possibly inline the row ID
-	if (count == 2) {
-		auto &segment = LeafSegment::Get(art, row_ids.ptr);
-		if (segment.row_ids[0] != row_id && segment.row_ids[1] != row_id) {
-			return;
-		}
-
-		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;
-	}
+	reference<Leaf> leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
-	// 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);
-	if (copy_idx == (uint32_t)DConstants::INVALID_INDEX) {
-		return;
+	// 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);
+			New(node, remaining_row_id);
+		}
+		return false;
 	}
-	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) {
+	// 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
 
-		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);
+	// go to the tail and keep track of the previous leaf node
+	reference<Leaf> prev_leaf(leaf);
+	while (leaf.get().ptr.HasMetadata()) {
+		prev_leaf = leaf;
+		leaf = Node::RefMutable<Leaf>(art, leaf.get().ptr, NType::LEAF);
+	}
 
-		// 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];
 
-		// 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++;
+	// 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--;
 	}
 
-	// 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()) {
-
-			// 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);
-
-			// next_segment is the tail of the segment list
-			if (!next_segment.next.IsSet()) {
-				Node::Free(art, current_segment.next);
+	// find the row ID and copy the last row ID to that position
+	while (node.get().HasMetadata()) {
+		leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
+		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;
 			}
-
-			// adjust loop variables
-			ptr = current_segment.next;
 		}
+		node = leaf.get().ptr;
 	}
-	count--;
+	return false;
 }
 
-row_t Leaf::GetRowId(const ART &art, const idx_t position) const {
+idx_t Leaf::TotalCount(ART &art, const Node &node) {
 
-	D_ASSERT(position < count);
-	if (IsInlined()) {
-		return row_ids.inlined;
+	D_ASSERT(node.HasMetadata());
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return 1;
 	}
 
-	// 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);
+	idx_t count = 0;
+	reference<const Node> node_ref(node);
+	while (node_ref.get().HasMetadata()) {
+		auto &leaf = Node::Ref<const Leaf>(art, node_ref, NType::LEAF);
+		count += leaf.count;
+		node_ref = leaf.ptr;
 	}
-
-	return segment.get().row_ids[position % Node::LEAF_SEGMENT_SIZE];
+	return count;
 }
 
-uint32_t Leaf::FindRowId(const ART &art, Node &ptr, const row_t row_id) const {
-
-	D_ASSERT(!IsInlined());
-
-	auto remaining = count;
-	while (ptr.IsSet()) {
+bool Leaf::GetRowIds(ART &art, const Node &node, vector<row_t> &result_ids, idx_t max_count) {
 
-		auto &segment = LeafSegment::Get(art, ptr);
-		auto search_count = MinValue(Node::LEAF_SEGMENT_SIZE, remaining);
+	// adding more elements would exceed the maximum count
+	D_ASSERT(node.HasMetadata());
+	if (result_ids.size() + TotalCount(art, node) > max_count) {
+		return false;
+	}
 
-		// search in this segment
-		for (idx_t i = 0; i < search_count; i++) {
-			if (segment.row_ids[i] == row_id) {
-				return count - remaining + i;
+	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<const Node> last_leaf_ref(node);
+		while (last_leaf_ref.get().HasMetadata()) {
+			auto &leaf = Node::Ref<const Leaf>(art, last_leaf_ref, NType::LEAF);
+			for (idx_t i = 0; i < leaf.count; i++) {
+				result_ids.push_back(leaf.row_ids[i]);
 			}
+			last_leaf_ref = leaf.ptr;
 		}
-
-		// adjust loop variables
-		remaining -= search_count;
-		ptr = segment.next;
 	}
-	return (uint32_t)DConstants::INVALID_INDEX;
+
+	return true;
 }
 
-string Leaf::VerifyAndToString(const ART &art, const bool only_verify) const {
+bool Leaf::ContainsRowId(ART &art, const Node &node, const row_t row_id) {
+
+	D_ASSERT(node.HasMetadata());
 
-	if (IsInlined()) {
-		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(row_ids.inlined) + "]";
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return node.GetRowId() == row_id;
 	}
 
-	auto ptr = row_ids.ptr;
-	auto remaining = count;
-	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<const Node> ref_node(node);
+	while (ref_node.get().HasMetadata()) {
+		auto &leaf = Node::Ref<const Leaf>(art, ref_node, NType::LEAF);
+		for (idx_t i = 0; i < leaf.count; i++) {
+			if (leaf.row_ids[i] == row_id) {
+				return true;
+			}
 		}
-		remaining -= to_string_count;
-		ptr = segment.next;
+		ref_node = leaf.ptr;
 	}
 
-	D_ASSERT(remaining == 0);
-	(void)this_count;
-	D_ASSERT(this_count == count);
-	return only_verify ? "" : "Leaf [count: " + to_string(count) + ", row IDs: " + str + "] \n";
+	return false;
 }
 
-BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
+string Leaf::VerifyAndToString(ART &art, const Node &node, const bool only_verify) {
 
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::LEAF);
-	writer.Write<uint32_t>(count);
-	prefix.Serialize(art, writer);
-
-	if (IsInlined()) {
-		writer.Write(row_ids.inlined);
-		return block_pointer;
+	if (node.GetType() == NType::LEAF_INLINED) {
+		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(node.GetRowId()) + "]";
 	}
 
-	D_ASSERT(row_ids.ptr.IsSet());
-	auto ptr = row_ids.ptr;
-	auto remaining = count;
+	string str = "";
 
-	// 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);
+	reference<const Node> node_ref(node);
+	while (node_ref.get().HasMetadata()) {
 
-		// write the row IDs
-		for (idx_t i = 0; i < write_count; i++) {
-			writer.Write(segment.row_ids[i]);
+		auto &leaf = Node::Ref<const Leaf>(art, node_ref, NType::LEAF);
+		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]) + "-";
 		}
+		str += "] ";
 
-		// adjust loop variables
-		remaining -= write_count;
-		ptr = segment.next;
+		node_ref = leaf.ptr;
 	}
-	D_ASSERT(remaining == 0);
-
-	return block_pointer;
+	return only_verify ? "" : str;
 }
 
-void Leaf::Deserialize(ART &art, MetaBlockReader &reader) {
+void Leaf::Vacuum(ART &art, Node &node) {
 
-	auto count_p = reader.Read<uint32_t>();
-	prefix.Deserialize(art, reader);
-
-	// inlined
-	if (count_p == 1) {
-		row_ids.inlined = reader.Read<row_t>();
-		count = count_p;
-		return;
-	}
+	auto &allocator = Node::GetAllocator(art, NType::LEAF);
 
-	// 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>());
+	reference<Node> node_ref(node);
+	while (node_ref.get().HasMetadata()) {
+		if (allocator.NeedsVacuum(node_ref)) {
+			node_ref.get() = allocator.VacuumPointer(node_ref);
+			node_ref.get().SetMetadata(static_cast<uint8_t>(NType::LEAF));
+		}
+		auto &leaf = Node::RefMutable<Leaf>(art, node_ref, NType::LEAF);
+		node_ref = leaf.ptr;
 	}
-	D_ASSERT(count_p == count);
 }
 
-void Leaf::Vacuum(ART &art) {
+void Leaf::MoveInlinedToLeaf(ART &art, Node &node) {
 
-	if (IsInlined()) {
-		return;
-	}
+	D_ASSERT(node.GetType() == NType::LEAF_INLINED);
+	auto row_id = node.GetRowId();
+	auto &leaf = New(art, 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;
-	}
-
-	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;
-		}
-	}
+	leaf.count = 1;
+	leaf.row_ids[0] = row_id;
 }
 
-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 = New(art, leaf.get().ptr);
+	}
 
-	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