duckdb 0.8.2-dev4025.0 → 0.8.2-dev4126.0

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

@@ -7,34 +7,34 @@
 
 namespace duckdb {
 
-bool IteratorKey::operator>(const ARTKey &k) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(key_bytes.size(), k.len); i++) {
-		if (key_bytes[i] > k.data[i]) {
+bool IteratorKey::operator>(const ARTKey &key) const {
+	for (idx_t i = 0; i < MinValue<idx_t>(key_bytes.size(), key.len); i++) {
+		if (key_bytes[i] > key.data[i]) {
 			return true;
-		} else if (key_bytes[i] < k.data[i]) {
+		} else if (key_bytes[i] < key.data[i]) {
 			return false;
 		}
 	}
-	return key_bytes.size() > k.len;
+	return key_bytes.size() > key.len;
 }
 
-bool IteratorKey::operator>=(const ARTKey &k) const {
-	for (idx_t i = 0; i < MinValue<idx_t>(key_bytes.size(), k.len); i++) {
-		if (key_bytes[i] > k.data[i]) {
+bool IteratorKey::operator>=(const ARTKey &key) const {
+	for (idx_t i = 0; i < MinValue<idx_t>(key_bytes.size(), key.len); i++) {
+		if (key_bytes[i] > key.data[i]) {
 			return true;
-		} else if (key_bytes[i] < k.data[i]) {
+		} else if (key_bytes[i] < key.data[i]) {
 			return false;
 		}
 	}
-	return key_bytes.size() >= k.len;
+	return key_bytes.size() >= key.len;
 }
 
-bool IteratorKey::operator==(const ARTKey &k) const {
+bool IteratorKey::operator==(const ARTKey &key) const {
 	// NOTE: we only use this for finding the LowerBound, in which case the length
 	// has to be equal
-	D_ASSERT(key_bytes.size() == k.len);
+	D_ASSERT(key_bytes.size() == key.len);
 	for (idx_t i = 0; i < key_bytes.size(); i++) {
-		if (key_bytes[i] != k.data[i]) {
+		if (key_bytes[i] != key.data[i]) {
 			return false;
 		}
 	}
@@ -71,12 +71,9 @@ bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row
 	return true;
 }
 
-void Iterator::FindMinimum(Node &node) {
+void Iterator::FindMinimum(const Node &node) {
 
-	D_ASSERT(node.IsSet());
-	if (node.IsSerialized()) {
-		node.Deserialize(*art);
-	}
+	D_ASSERT(node.HasMetadata());
 
 	// found the minimum
 	if (node.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
@@ -86,7 +83,7 @@ void Iterator::FindMinimum(Node &node) {
 
 	// traverse the prefix
 	if (node.GetType() == NType::PREFIX) {
-		auto &prefix = Prefix::Get(*art, node);
+		auto &prefix = Node::Ref<const Prefix>(*art, node, NType::PREFIX);
 		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
 			current_key.Push(prefix.data[i]);
 		}
@@ -103,16 +100,12 @@ void Iterator::FindMinimum(Node &node) {
 	FindMinimum(*next);
 }
 
-bool Iterator::LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t depth) {
+bool Iterator::LowerBound(const Node &node, const ARTKey &key, const bool equal, idx_t depth) {
 
-	if (!node.IsSet()) {
+	if (!node.HasMetadata()) {
 		return false;
 	}
 
-	if (node.IsSerialized()) {
-		node.Deserialize(*art);
-	}
-
 	// we found the lower bound
 	if (node.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
 		if (!equal && current_key == key) {
@@ -145,7 +138,7 @@ bool Iterator::LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t
 	}
 
 	// resolve the prefix
-	auto &prefix = Prefix::Get(*art, node);
+	auto &prefix = Node::Ref<const Prefix>(*art, node, NType::PREFIX);
 	for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
 		current_key.Push(prefix.data[i]);
 	}
@@ -206,7 +199,8 @@ bool Iterator::Next() {
 
 void Iterator::PopNode() {
 	if (nodes.top().node.GetType() == NType::PREFIX) {
-		auto prefix_byte_count = Prefix::Get(*art, nodes.top().node).data[Node::PREFIX_SIZE];
+		auto &prefix = Node::Ref<const Prefix>(*art, nodes.top().node, NType::PREFIX);
+		auto prefix_byte_count = prefix.data[Node::PREFIX_SIZE];
 		current_key.Pop(prefix_byte_count);
 	} else {
 		current_key.Pop(1);

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

@@ -2,8 +2,6 @@
 
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -11,8 +9,8 @@ void Leaf::New(Node &node, const row_t row_id) {
 
 	// 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.Clear();
+	node.SetMetadata(static_cast<uint8_t>(NType::LEAF_INLINED));
 	node.SetRowId(row_id);
 }
 
@@ -23,9 +21,9 @@ void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t coun
 	idx_t copy_count = 0;
 	while (count) {
 		node.get() = Node::GetAllocator(art, NType::LEAF).New();
-		node.get().SetType((uint8_t)NType::LEAF);
+		node.get().SetMetadata(static_cast<uint8_t>(NType::LEAF));
 
-		auto &leaf = Leaf::Get(art, node);
+		auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
 		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count);
 		for (idx_t i = 0; i < leaf.count; i++) {
@@ -36,7 +34,7 @@ void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t coun
 		count -= leaf.count;
 
 		node = leaf.ptr;
-		leaf.ptr.Reset();
+		leaf.ptr.Clear();
 	}
 }
 
@@ -44,40 +42,39 @@ void Leaf::Free(ART &art, Node &node) {
 
 	Node current_node = node;
 	Node next_node;
-	while (current_node.IsSet() && !current_node.IsSerialized()) {
-		next_node = Leaf::Get(art, current_node).ptr;
+	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.Reset();
+	node.Clear();
 }
 
 void Leaf::InitializeMerge(ART &art, Node &node, const ARTFlags &flags) {
 
-	auto merge_buffer_count = flags.merge_buffer_counts[(uint8_t)NType::LEAF - 1];
+	auto merge_buffer_count = flags.merge_buffer_counts[static_cast<uint8_t>(NType::LEAF) - 1];
 
 	Node next_node = node;
-	node.AddToBufferID(merge_buffer_count);
+	node.IncreaseBufferId(merge_buffer_count);
 
-	while (next_node.IsSet()) {
-		auto &leaf = Leaf::Get(art, next_node);
+	while (next_node.HasMetadata()) {
+		auto &leaf = Node::RefMutable<Leaf>(art, next_node, NType::LEAF);
 		next_node = leaf.ptr;
-		if (leaf.ptr.IsSet()) {
-			leaf.ptr.AddToBufferID(merge_buffer_count);
+		if (leaf.ptr.HasMetadata()) {
+			leaf.ptr.IncreaseBufferId(merge_buffer_count);
 		}
 	}
 }
 
 void Leaf::Merge(ART &art, Node &l_node, Node &r_node) {
 
-	D_ASSERT(l_node.IsSet() && !l_node.IsSerialized());
-	D_ASSERT(r_node.IsSet() && !r_node.IsSerialized());
+	D_ASSERT(l_node.HasMetadata() && r_node.HasMetadata());
 
 	// 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();
+		Insert(art, l_node, r_node.GetRowId());
+		r_node.Clear();
 		return;
 	}
 
@@ -85,8 +82,8 @@ void Leaf::Merge(ART &art, Node &l_node, Node &r_node) {
 	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();
+		Insert(art, l_node, row_id);
+		r_node.Clear();
 		return;
 	}
 
@@ -94,33 +91,33 @@ void Leaf::Merge(ART &art, Node &l_node, Node &r_node) {
 	D_ASSERT(r_node.GetType() != NType::LEAF_INLINED);
 
 	reference<Node> l_node_ref(l_node);
-	reference<Leaf> l_leaf = Leaf::Get(art, l_node_ref);
+	reference<Leaf> l_leaf = Node::RefMutable<Leaf>(art, l_node_ref, NType::LEAF);
 
 	// find a non-full node
 	while (l_leaf.get().count == Node::LEAF_SIZE) {
 		l_node_ref = l_leaf.get().ptr;
 
 		// the last leaf is full
-		if (!l_leaf.get().ptr.IsSet()) {
+		if (!l_leaf.get().ptr.HasMetadata()) {
 			break;
 		}
-		l_leaf = Leaf::Get(art, l_node_ref);
+		l_leaf = Node::RefMutable<Leaf>(art, l_node_ref, NType::LEAF);
 	}
 
 	// 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();
+	r_node.Clear();
 
 	// append the remaining row IDs of the last leaf node
-	if (last_leaf_node.IsSet()) {
+	if (last_leaf_node.HasMetadata()) {
 		// 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);
+		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 = Leaf::Get(art, last_leaf_node);
+		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]);
 		}
@@ -130,28 +127,25 @@ void Leaf::Merge(ART &art, Node &l_node, Node &r_node) {
 
 void Leaf::Insert(ART &art, Node &node, const row_t row_id) {
 
-	D_ASSERT(node.IsSet() && !node.IsSerialized());
+	D_ASSERT(node.HasMetadata());
 
 	if (node.GetType() == NType::LEAF_INLINED) {
-		Leaf::MoveInlinedToLeaf(art, node);
-		Leaf::Insert(art, node, row_id);
+		MoveInlinedToLeaf(art, node);
+		Insert(art, node, row_id);
 		return;
 	}
 
 	// append to the tail
-	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);
+	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);
 }
 
 bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 
-	D_ASSERT(node.get().IsSet() && !node.get().IsSerialized());
+	D_ASSERT(node.get().HasMetadata());
 
 	if (node.get().GetType() == NType::LEAF_INLINED) {
 		if (node.get().GetRowId() == row_id) {
@@ -160,14 +154,14 @@ bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 		return false;
 	}
 
-	reference<Leaf> leaf = Leaf::Get(art, node);
+	reference<Leaf> leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
 	// 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);
+			New(node, remaining_row_id);
 		}
 		return false;
 	}
@@ -177,12 +171,9 @@ bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 
 	// go to the tail and keep track of the previous leaf node
 	reference<Leaf> prev_leaf(leaf);
-	while (leaf.get().ptr.IsSet()) {
+	while (leaf.get().ptr.HasMetadata()) {
 		prev_leaf = leaf;
-		if (leaf.get().ptr.IsSerialized()) {
-			leaf.get().ptr.Deserialize(art);
-		}
-		leaf = Leaf::Get(art, leaf.get().ptr);
+		leaf = Node::RefMutable<Leaf>(art, leaf.get().ptr, NType::LEAF);
 	}
 
 	auto last_idx = leaf.get().count;
@@ -199,9 +190,8 @@ bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 	}
 
 	// 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);
+	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;
@@ -213,54 +203,43 @@ bool Leaf::Remove(ART &art, reference<Node> &node, const row_t row_id) {
 	return false;
 }
 
-idx_t Leaf::TotalCount(ART &art, Node &node) {
-
-	// NOTE: first leaf in the leaf chain is already deserialized
-	D_ASSERT(node.IsSet() && !node.IsSerialized());
+idx_t Leaf::TotalCount(ART &art, const Node &node) {
 
+	D_ASSERT(node.HasMetadata());
 	if (node.GetType() == NType::LEAF_INLINED) {
 		return 1;
 	}
 
 	idx_t count = 0;
-	reference<Node> node_ref(node);
-	while (node_ref.get().IsSet()) {
-		auto &leaf = Leaf::Get(art, node_ref);
+	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;
-
-		if (leaf.ptr.IsSerialized()) {
-			leaf.ptr.Deserialize(art);
-		}
 		node_ref = leaf.ptr;
 	}
 	return count;
 }
 
-bool Leaf::GetRowIds(ART &art, Node &node, vector<row_t> &result_ids, idx_t max_count) {
+bool Leaf::GetRowIds(ART &art, const Node &node, vector<row_t> &result_ids, idx_t max_count) {
 
 	// adding more elements would exceed the maximum count
-	D_ASSERT(node.IsSet());
-	if (result_ids.size() + Leaf::TotalCount(art, node) > max_count) {
+	D_ASSERT(node.HasMetadata());
+	if (result_ids.size() + TotalCount(art, node) > max_count) {
 		return false;
 	}
 
-	// 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);
+		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]);
 			}
-
-			D_ASSERT(!leaf.ptr.IsSerialized());
 			last_leaf_ref = leaf.ptr;
 		}
 	}
@@ -268,45 +247,40 @@ bool Leaf::GetRowIds(ART &art, Node &node, vector<row_t> &result_ids, idx_t max_
 	return true;
 }
 
-bool Leaf::ContainsRowId(ART &art, Node &node, const row_t row_id) {
+bool Leaf::ContainsRowId(ART &art, const Node &node, const row_t row_id) {
 
-	// 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());
+	D_ASSERT(node.HasMetadata());
 
 	if (node.GetType() == NType::LEAF_INLINED) {
 		return node.GetRowId() == row_id;
 	}
 
-	reference<Node> ref_node(node);
-	while (ref_node.get().IsSet()) {
-		auto &leaf = Leaf::Get(art, ref_node);
+	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;
 			}
 		}
-
-		D_ASSERT(!leaf.ptr.IsSerialized());
 		ref_node = leaf.ptr;
 	}
 
 	return false;
 }
 
-string Leaf::VerifyAndToString(ART &art, Node &node) {
+string Leaf::VerifyAndToString(ART &art, const Node &node, const bool only_verify) {
 
 	if (node.GetType() == NType::LEAF_INLINED) {
-		return "Leaf [count: 1, row ID: " + to_string(node.GetRowId()) + "]";
+		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(node.GetRowId()) + "]";
 	}
 
 	string str = "";
 
-	reference<Node> node_ref(node);
-	while (node_ref.get().IsSet()) {
+	reference<const Node> node_ref(node);
+	while (node_ref.get().HasMetadata()) {
 
-		auto &leaf = Leaf::Get(art, node_ref);
+		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: ";
@@ -315,64 +289,9 @@ string Leaf::VerifyAndToString(ART &art, Node &node) {
 		}
 		str += "] ";
 
-		// 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(ART &art, Node &node, MetadataWriter &writer) {
-
-	if (node.GetType() == NType::LEAF_INLINED) {
-		auto block_pointer = writer.GetBlockPointer();
-		writer.Write(NType::LEAF_INLINED);
-		writer.Write(node.GetRowId());
-		return block_pointer;
-	}
-
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::LEAF);
-	idx_t total_count = Leaf::TotalCount(art, node);
-	writer.Write<idx_t>(total_count);
-
-	// iterate all leaves and write their row IDs
-	reference<Node> ref_node(node);
-	while (ref_node.get().IsSet()) {
-		D_ASSERT(!ref_node.get().IsSerialized());
-		auto &leaf = Leaf::Get(art, ref_node);
-
-		// write row IDs
-		for (idx_t i = 0; i < leaf.count; i++) {
-			writer.Write(leaf.row_ids[i]);
-		}
-		ref_node = leaf.ptr;
-	}
-
-	return block_pointer;
-}
-
-void Leaf::Deserialize(ART &art, Node &node, MetadataReader &reader) {
-
-	auto total_count = reader.Read<idx_t>();
-	reference<Node> ref_node(node);
-
-	while (total_count) {
-		ref_node.get() = Node::GetAllocator(art, NType::LEAF).New();
-		ref_node.get().SetType((uint8_t)NType::LEAF);
-
-		auto &leaf = Leaf::Get(art, ref_node);
-
-		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, total_count);
-		for (idx_t i = 0; i < leaf.count; i++) {
-			leaf.row_ids[i] = reader.Read<row_t>();
-		}
-
-		total_count -= leaf.count;
-		ref_node = leaf.ptr;
-		leaf.ptr.Reset();
-	}
+	return only_verify ? "" : str;
 }
 
 void Leaf::Vacuum(ART &art, Node &node) {
@@ -380,12 +299,12 @@ void Leaf::Vacuum(ART &art, Node &node) {
 	auto &allocator = Node::GetAllocator(art, NType::LEAF);
 
 	reference<Node> node_ref(node);
-	while (node_ref.get().IsSet() && !node_ref.get().IsSerialized()) {
+	while (node_ref.get().HasMetadata()) {
 		if (allocator.NeedsVacuum(node_ref)) {
 			node_ref.get() = allocator.VacuumPointer(node_ref);
-			node_ref.get().SetType((uint8_t)NType::LEAF);
+			node_ref.get().SetMetadata(static_cast<uint8_t>(NType::LEAF));
 		}
-		auto &leaf = Leaf::Get(art, node_ref);
+		auto &leaf = Node::RefMutable<Leaf>(art, node_ref, NType::LEAF);
 		node_ref = leaf.ptr;
 	}
 }
@@ -395,12 +314,12 @@ 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);
+	node.SetMetadata(static_cast<uint8_t>(NType::LEAF));
 
-	auto &leaf = Leaf::Get(art, node);
+	auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 	leaf.count = 1;
 	leaf.row_ids[0] = row_id;
-	leaf.ptr.Reset();
+	leaf.ptr.Clear();
 }
 
 Leaf &Leaf::Append(ART &art, const row_t row_id) {
@@ -410,11 +329,11 @@ Leaf &Leaf::Append(ART &art, const row_t row_id) {
 	// 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.get().ptr.SetMetadata(static_cast<uint8_t>(NType::LEAF));
 
-		leaf = Leaf::Get(art, leaf.get().ptr);
+		leaf = Node::RefMutable<Leaf>(art, leaf.get().ptr, NType::LEAF);
 		leaf.get().count = 0;
-		leaf.get().ptr.Reset();
+		leaf.get().ptr.Clear();
 	}
 
 	leaf.get().row_ids[leaf.get().count] = row_id;