duckdb 0.7.2-dev2552.0 → 0.7.2-dev2675.0

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

@@ -1,31 +1,34 @@
 #include "duckdb/execution/index/art/iterator.hpp"
 
+#include "duckdb/common/limits.hpp"
 #include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
-uint8_t &IteratorCurrentKey::operator[](idx_t idx) {
-	if (idx >= key.size()) {
-		key.push_back(0);
-	}
-	D_ASSERT(idx < key.size());
-	return key[idx];
-}
 
-//! Push Byte
-void IteratorCurrentKey::Push(uint8_t byte) {
+void IteratorCurrentKey::Push(const uint8_t byte) {
 	if (cur_key_pos == key.size()) {
 		key.push_back(byte);
 	}
 	D_ASSERT(cur_key_pos < key.size());
 	key[cur_key_pos++] = byte;
 }
-//! Pops n elements
-void IteratorCurrentKey::Pop(idx_t n) {
+
+void IteratorCurrentKey::Pop(const idx_t n) {
 	cur_key_pos -= n;
 	D_ASSERT(cur_key_pos <= key.size());
 }
 
-bool IteratorCurrentKey::operator>(const Key &k) const {
+uint8_t &IteratorCurrentKey::operator[](idx_t idx) {
+	if (idx >= key.size()) {
+		key.push_back(0);
+	}
+	D_ASSERT(idx < key.size());
+	return key[idx];
+}
+
+bool IteratorCurrentKey::operator>(const ARTKey &k) const {
 	for (idx_t i = 0; i < MinValue<idx_t>(cur_key_pos, k.len); i++) {
 		if (key[i] > k.data[i]) {
 			return true;
@@ -36,7 +39,7 @@ bool IteratorCurrentKey::operator>(const Key &k) const {
 	return cur_key_pos > k.len;
 }
 
-bool IteratorCurrentKey::operator>=(const Key &k) const {
+bool IteratorCurrentKey::operator>=(const ARTKey &k) const {
 	for (idx_t i = 0; i < MinValue<idx_t>(cur_key_pos, k.len); i++) {
 		if (key[i] > k.data[i]) {
 			return true;
@@ -47,7 +50,7 @@ bool IteratorCurrentKey::operator>=(const Key &k) const {
 	return cur_key_pos >= k.len;
 }
 
-bool IteratorCurrentKey::operator==(const Key &k) const {
+bool IteratorCurrentKey::operator==(const ARTKey &k) const {
 	if (cur_key_pos != k.len) {
 		return false;
 	}
@@ -60,96 +63,76 @@ bool IteratorCurrentKey::operator==(const Key &k) const {
 }
 
 void Iterator::FindMinimum(Node &node) {
-	Node *next = nullptr;
-	idx_t pos = 0;
+
 	// reconstruct the prefix
-	for (idx_t i = 0; i < node.prefix.Size(); i++) {
-		cur_key.Push(node.prefix[i]);
+	// FIXME: get all bytes at once to increase performance
+	auto &node_prefix = node.GetPrefix(*art);
+	for (idx_t i = 0; i < node_prefix.count; i++) {
+		cur_key.Push(node_prefix.GetByte(*art, i));
 	}
-	switch (node.type) {
-	case NodeType::NLeaf:
-		last_leaf = (Leaf *)&node;
+
+	// found the minimum
+	if (node.DecodeARTNodeType() == NType::LEAF) {
+		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
 		return;
-	case NodeType::N4: {
-		next = ((Node4 &)node).children[0].Unswizzle(*art);
-		cur_key.Push(((Node4 &)node).key[0]);
-		break;
-	}
-	case NodeType::N16: {
-		next = ((Node16 &)node).children[0].Unswizzle(*art);
-		cur_key.Push(((Node16 &)node).key[0]);
-		break;
-	}
-	case NodeType::N48: {
-		auto &n48 = (Node48 &)node;
-		while (n48.child_index[pos] == Node::EMPTY_MARKER) {
-			pos++;
-		}
-		cur_key.Push(pos);
-		next = n48.children[n48.child_index[pos]].Unswizzle(*art);
-		break;
-	}
-	case NodeType::N256: {
-		auto &n256 = (Node256 &)node;
-		while (!n256.children[pos]) {
-			pos++;
-		}
-		cur_key.Push(pos);
-		next = (Node *)n256.children[pos].Unswizzle(*art);
-		break;
-	}
 	}
-	nodes.push(IteratorEntry(&node, pos));
+
+	// go to the leftmost entry in the current node
+	uint8_t byte = 0;
+	auto next = node.GetNextChild(*art, byte);
+	D_ASSERT(next);
+	cur_key.Push(byte);
+
+	// recurse
+	nodes.emplace(node, byte);
 	FindMinimum(*next);
 }
 
-void Iterator::PushKey(Node *cur_node, uint16_t pos) {
-	switch (cur_node->type) {
-	case NodeType::N4:
-		cur_key.Push(((Node4 *)cur_node)->key[pos]);
-		break;
-	case NodeType::N16:
-		cur_key.Push(((Node16 *)cur_node)->key[pos]);
-		break;
-	case NodeType::N48:
-	case NodeType::N256:
-		cur_key.Push(pos);
-		break;
-	case NodeType::NLeaf:
-		break;
+void Iterator::PushKey(const Node &node, const uint8_t byte) {
+	if (node.DecodeARTNodeType() != NType::LEAF) {
+		cur_key.Push(byte);
 	}
 }
 
-bool Iterator::Scan(Key &bound, idx_t max_count, vector<row_t> &result_ids, bool is_inclusive) {
+bool Iterator::Scan(const ARTKey &key, const idx_t &max_count, vector<row_t> &result_ids, const bool &is_inclusive) {
+
 	bool has_next;
 	do {
-		if (!bound.Empty()) {
+		if (!key.Empty()) {
+			// no more row IDs within the key bounds
 			if (is_inclusive) {
-				if (cur_key > bound) {
-					break;
+				if (cur_key > key) {
+					return true;
 				}
 			} else {
-				if (cur_key >= bound) {
-					break;
+				if (cur_key >= key) {
+					return true;
 				}
 			}
 		}
+
+		// adding more elements would exceed the max count
 		if (result_ids.size() + last_leaf->count > max_count) {
-			// adding these elements would exceed the max count
 			return false;
 		}
+
+		// FIXME: copy all at once to improve performance
 		for (idx_t i = 0; i < last_leaf->count; i++) {
-			row_t row_id = last_leaf->GetRowId(i);
+			row_t row_id = last_leaf->GetRowId(*art, i);
 			result_ids.push_back(row_id);
 		}
+
+		// get the next leaf
 		has_next = Next();
+
 	} while (has_next);
+
 	return true;
 }
 
 void Iterator::PopNode() {
 	auto cur_node = nodes.top();
-	idx_t elements_to_pop = cur_node.node->prefix.Size() + (nodes.size() != 1);
+	idx_t elements_to_pop = cur_node.node.GetPrefix(*art).count + (nodes.size() != 1);
 	cur_key.Pop(elements_to_pop);
 	nodes.pop();
 }
@@ -157,79 +140,110 @@ void Iterator::PopNode() {
 bool Iterator::Next() {
 	if (!nodes.empty()) {
 		auto cur_node = nodes.top().node;
-		if (cur_node->type == NodeType::NLeaf) {
-			// Pop Leaf (We must pop the prefix size + the key to the node (unless we are popping the root)
+		if (cur_node.DecodeARTNodeType() == NType::LEAF) {
+			// pop leaf
+			// we must pop the prefix size + the key to the node, unless we are popping the root
 			PopNode();
 		}
 	}
 
-	// Look for the next leaf
+	// look for the next leaf
 	while (!nodes.empty()) {
+
 		// cur_node
 		auto &top = nodes.top();
-		Node *node = top.node;
-		if (node->type == NodeType::NLeaf) {
-			// found a leaf: move to next node
-			last_leaf = (Leaf *)node;
+		Node node = top.node;
+
+		// found a leaf: move to next node
+		if (node.DecodeARTNodeType() == NType::LEAF) {
+			last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
 			return true;
 		}
-		// Find next node
-		top.pos = node->GetNextPos(top.pos);
-		if (top.pos != DConstants::INVALID_INDEX) {
-			// add key-byte of the new node
-			PushKey(node, top.pos);
-			auto next_node = node->GetChild(*art, top.pos);
+
+		// find next node
+		if (top.byte == NumericLimits<uint8_t>::Maximum()) {
+			// no node found: move up the tree, pop prefix and key of current node
+			PopNode();
+			continue;
+		}
+
+		top.byte == 0 ? top.byte : top.byte++;
+		auto next_node = node.GetNextChild(*art, top.byte);
+
+		if (next_node) {
+			// add the next node's key byte
+			PushKey(node, top.byte);
+
 			// add prefix of new node
-			for (idx_t i = 0; i < next_node->prefix.Size(); i++) {
-				cur_key.Push(next_node->prefix[i]);
+			// FIXME: get all bytes at once to increase performance
+			auto &next_node_prefix = next_node->GetPrefix(*art);
+			for (idx_t i = 0; i < next_node_prefix.count; i++) {
+				cur_key.Push(next_node_prefix.GetByte(*art, i));
 			}
+
 			// next node found: push it
-			nodes.push(IteratorEntry(next_node, DConstants::INVALID_INDEX));
+			nodes.emplace(*next_node, 0);
 		} else {
-			// no node found: move up the tree and Pop prefix and key of current node
+
+			// no node found: move up the tree, pop prefix and key of current node
 			PopNode();
 		}
 	}
 	return false;
 }
 
-bool Iterator::LowerBound(Node *node, Key &key, bool inclusive) {
-	bool equal = true;
-	if (!node) {
+bool Iterator::LowerBound(Node node, const ARTKey &key, const bool &is_inclusive) {
+
+	if (!node.IsSet()) {
 		return false;
 	}
+
 	idx_t depth = 0;
+	bool equal = true;
 	while (true) {
-		nodes.push(IteratorEntry(node, 0));
+
+		nodes.emplace(node, 0);
 		auto &top = nodes.top();
+
 		// reconstruct the prefix
-		for (idx_t i = 0; i < top.node->prefix.Size(); i++) {
-			cur_key.Push(top.node->prefix[i]);
+		// FIXME: get all bytes at once to increase performance
+		reference<Prefix> node_prefix(top.node.GetPrefix(*art));
+		for (idx_t i = 0; i < node_prefix.get().count; i++) {
+			cur_key.Push(node_prefix.get().GetByte(*art, i));
 		}
+
 		// greater case: find leftmost leaf node directly
 		if (!equal) {
-			while (node->type != NodeType::NLeaf) {
-				auto min_pos = node->GetMin();
-				PushKey(node, min_pos);
-				nodes.push(IteratorEntry(node, min_pos));
-				node = node->GetChild(*art, min_pos);
+			while (node.DecodeARTNodeType() != NType::LEAF) {
+
+				uint8_t byte = 0;
+				auto next_node = *node.GetNextChild(*art, byte);
+				D_ASSERT(next_node.IsSet());
+
+				PushKey(node, byte);
+				nodes.emplace(node, byte);
+				node = next_node;
+
 				// reconstruct the prefix
-				for (idx_t i = 0; i < node->prefix.Size(); i++) {
-					cur_key.Push(node->prefix[i]);
+				node_prefix = node.GetPrefix(*art);
+				for (idx_t i = 0; i < node_prefix.get().count; i++) {
+					cur_key.Push(node_prefix.get().GetByte(*art, i));
 				}
+
 				auto &c_top = nodes.top();
 				c_top.node = node;
 			}
 		}
-		if (node->type == NodeType::NLeaf) {
+
+		if (node.DecodeARTNodeType() == NType::LEAF) {
 			// found a leaf node: check if it is bigger or equal than the current key
-			auto leaf = static_cast<Leaf *>(node);
-			last_leaf = leaf;
+			last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
+
 			// if the search is not inclusive the leaf node could still be equal to the current value
 			// check if leaf is equal to the current key
 			if (cur_key == key) {
 				// if it's not inclusive check if there is a next leaf
-				if (!inclusive && !Next()) {
+				if (!is_inclusive && !Next()) {
 					return false;
 				} else {
 					return true;
@@ -248,33 +262,38 @@ bool Iterator::LowerBound(Node *node, Key &key, bool inclusive) {
 
 			return Next();
 		}
+
 		// equal case:
-		uint32_t mismatch_pos = node->prefix.KeyMismatchPosition(key, depth);
-		if (mismatch_pos != node->prefix.Size()) {
-			if (node->prefix[mismatch_pos] < key[depth + mismatch_pos]) {
-				// Less
+		node_prefix = node.GetPrefix(*art);
+		auto mismatch_pos = node_prefix.get().KeyMismatchPosition(*art, key, depth);
+		if (mismatch_pos != node_prefix.get().count) {
+			if (node_prefix.get().GetByte(*art, mismatch_pos) < key[depth + mismatch_pos]) {
+				// less
 				PopNode();
 				return Next();
-			} else {
-				// Greater
-				top.pos = DConstants::INVALID_INDEX;
-				return Next();
 			}
+			// greater
+			top.byte = 0;
+			return Next();
 		}
 
 		// prefix matches, search inside the child for the key
-		depth += node->prefix.Size();
+		depth += node_prefix.get().count;
+		top.byte = key[depth];
+		auto child = node.GetNextChild(*art, top.byte);
+		equal = key[depth] == top.byte;
 
-		top.pos = node->GetChildGreaterEqual(key[depth], equal);
-		// The maximum key byte of the current node is less than the key
-		// So fall back to the previous node
-		if (top.pos == DConstants::INVALID_INDEX) {
+		// the maximum key byte of the current node is less than the key
+		// fall back to the previous node
+		if (!child) {
 			PopNode();
 			return Next();
 		}
-		PushKey(node, top.pos);
-		node = node->GetChild(*art, top.pos);
-		// This means all children of this node qualify as geq
+
+		PushKey(node, top.byte);
+		node = *child;
+
+		// all children of this node qualify as greater or equal
 		depth++;
 	}
 }