duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

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

@@ -7,111 +7,58 @@
 
 namespace duckdb {
 
-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;
-}
-
-void IteratorCurrentKey::Pop(const idx_t n) {
-	cur_key_pos -= n;
-	D_ASSERT(cur_key_pos <= key.size());
-}
-
-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]) {
+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]) {
 			return true;
-		} else if (key[i] < k.data[i]) {
+		} else if (key_bytes[i] < k.data[i]) {
 			return false;
 		}
 	}
-	return cur_key_pos > k.len;
+	return key_bytes.size() > k.len;
 }
 
-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]) {
+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]) {
 			return true;
-		} else if (key[i] < k.data[i]) {
+		} else if (key_bytes[i] < k.data[i]) {
 			return false;
 		}
 	}
-	return cur_key_pos >= k.len;
+	return key_bytes.size() >= k.len;
 }
 
-bool IteratorCurrentKey::operator==(const ARTKey &k) const {
-	if (cur_key_pos != k.len) {
-		return false;
-	}
-	for (idx_t i = 0; i < cur_key_pos; i++) {
-		if (key[i] != k.data[i]) {
+bool IteratorKey::operator==(const ARTKey &k) 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);
+	for (idx_t i = 0; i < key_bytes.size(); i++) {
+		if (key_bytes[i] != k.data[i]) {
 			return false;
 		}
 	}
 	return true;
 }
 
-void Iterator::FindMinimum(Node &node) {
-
-	// reconstruct the prefix
-	// 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));
-	}
-
-	// found the minimum
-	if (node.DecodeARTNodeType() == NType::LEAF) {
-		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
-		return;
-	}
-
-	// 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(const Node &node, const uint8_t byte) {
-	if (node.DecodeARTNodeType() != NType::LEAF) {
-		cur_key.Push(byte);
-	}
-}
-
-bool Iterator::Scan(const ARTKey &key, const idx_t &max_count, vector<row_t> &result_ids, const bool &is_inclusive) {
+bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row_t> &result_ids, const bool equal) {
 
 	bool has_next;
 	do {
-		if (!key.Empty()) {
+		if (!upper_bound.Empty()) {
 			// no more row IDs within the key bounds
-			if (is_inclusive) {
-				if (cur_key > key) {
+			if (equal) {
+				if (current_key > upper_bound) {
 					return true;
 				}
 			} else {
-				if (cur_key >= key) {
+				if (current_key >= upper_bound) {
 					return true;
 				}
 			}
 		}
 
-		// adding more elements would exceed the max count
+		// adding more elements would exceed the maximum count
 		if (result_ids.size() + last_leaf->count > max_count) {
 			return false;
 		}
@@ -130,172 +77,147 @@ bool Iterator::Scan(const ARTKey &key, const idx_t &max_count, vector<row_t> &re
 	return true;
 }
 
-void Iterator::PopNode() {
-	auto cur_node = nodes.top();
-	idx_t elements_to_pop = cur_node.node.GetPrefix(*art).count + (nodes.size() != 1);
-	cur_key.Pop(elements_to_pop);
-	nodes.pop();
-}
+void Iterator::FindMinimum(Node &node) {
 
-bool Iterator::Next() {
-	if (!nodes.empty()) {
-		auto cur_node = nodes.top().node;
-		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();
-		}
+	D_ASSERT(node.IsSet());
+	if (node.IsSwizzled()) {
+		node.Deserialize(*art);
 	}
 
-	// look for the next leaf
-	while (!nodes.empty()) {
-
-		// cur_node
-		auto &top = nodes.top();
-		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
-		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
-			// 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.emplace(*next_node, 0);
-		} else {
+	// found the minimum
+	if (node.DecodeARTNodeType() == NType::LEAF) {
+		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
+		return;
+	}
 
-			// no node found: move up the tree, pop prefix and key of current node
-			PopNode();
+	// traverse the prefix
+	if (node.DecodeARTNodeType() == NType::PREFIX) {
+		auto &prefix = Prefix::Get(*art, node);
+		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
+			current_key.Push(prefix.data[i]);
 		}
+		nodes.emplace(node, 0);
+		return FindMinimum(prefix.ptr);
 	}
-	return false;
+
+	// go to the leftmost entry in the current node and recurse
+	uint8_t byte = 0;
+	auto next = node.GetNextChild(*art, byte);
+	D_ASSERT(next);
+	current_key.Push(byte);
+	nodes.emplace(node, byte);
+	FindMinimum(*next);
 }
 
-bool Iterator::LowerBound(Node node, const ARTKey &key, const bool &is_inclusive) {
+bool Iterator::LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t depth) {
 
 	if (!node.IsSet()) {
 		return false;
 	}
 
-	idx_t depth = 0;
-	bool equal = true;
-	while (true) {
+	if (node.IsSwizzled()) {
+		node.Deserialize(*art);
+	}
 
-		nodes.emplace(node, 0);
-		auto &top = nodes.top();
+	// we found the lower bound
+	if (node.DecodeARTNodeType() == NType::LEAF) {
+		if (!equal && current_key == key) {
+			return Next();
+		}
+		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
+		return true;
+	}
 
-		// reconstruct the prefix
-		// 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));
+	if (node.DecodeARTNodeType() != NType::PREFIX) {
+		auto next_byte = key[depth];
+		auto child = node.GetNextChild(*art, next_byte);
+		if (!child) {
+			// the key is greater than any key in this subtree
+			return Next();
 		}
 
-		// greater case: find leftmost leaf node directly
-		if (!equal) {
-			while (node.DecodeARTNodeType() != NType::LEAF) {
+		current_key.Push(next_byte);
+		nodes.emplace(node, next_byte);
 
-				uint8_t byte = 0;
-				auto next_node = *node.GetNextChild(*art, byte);
-				D_ASSERT(next_node.IsSet());
+		if (next_byte > key[depth]) {
+			// we only need to find the minimum from here
+			// because all keys will be greater than the lower bound
+			FindMinimum(*child);
+			return true;
+		}
 
-				PushKey(node, byte);
-				nodes.emplace(node, byte);
-				node = next_node;
+		// recurse into the child
+		return LowerBound(*child, key, equal, depth + 1);
+	}
 
-				// reconstruct the prefix
-				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));
-				}
+	// resolve the prefix
+	auto &prefix = Prefix::Get(*art, node);
+	for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
+		current_key.Push(prefix.data[i]);
+	}
+	nodes.emplace(node, 0);
 
-				auto &c_top = nodes.top();
-				c_top.node = node;
-			}
+	for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
+		// the key down to this node is less than the lower bound, the next key will be
+		// greater than the lower bound
+		if (prefix.data[i] < key[depth + i]) {
+			return Next();
+		}
+		// we only need to find the minimum from here
+		// because all keys will be greater than the lower bound
+		if (prefix.data[i] > key[depth + i]) {
+			FindMinimum(prefix.ptr);
+			return true;
 		}
+	}
 
-		if (node.DecodeARTNodeType() == NType::LEAF) {
-			// found a leaf node: check if it is bigger or equal than the current key
-			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 (!is_inclusive && !Next()) {
-					return false;
-				} else {
-					return true;
-				}
-			}
+	// recurse into the child
+	depth += prefix.data[Node::PREFIX_SIZE];
+	return LowerBound(prefix.ptr, key, equal, depth);
+}
 
-			if (cur_key > key) {
-				return true;
-			}
-			// Case1: When the ART has only one leaf node, the Next() will return false
-			// Case2: This means the previous node prefix(if any) + a_key(one element of of key array of previous node)
-			// == key[q..=w].
-			// But key[w+1..=z] maybe greater than leaf node prefix.
-			// One fact is key[w] is alawys equal to a_key and the next element
-			// of key array of previous node is always > a_key So we just call Next() once.
+bool Iterator::Next() {
 
-			return Next();
-		}
+	while (!nodes.empty()) {
 
-		// equal case:
-		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();
-			}
-			// greater
-			top.byte = 0;
-			return Next();
+		auto &top = nodes.top();
+		D_ASSERT(top.node.DecodeARTNodeType() != NType::LEAF);
+
+		if (top.node.DecodeARTNodeType() == NType::PREFIX) {
+			PopNode();
+			continue;
 		}
 
-		// prefix matches, search inside the child for the key
-		depth += node_prefix.get().count;
-		top.byte = key[depth];
-		auto child = node.GetNextChild(*art, top.byte);
-		equal = key[depth] == top.byte;
+		if (top.byte == NumericLimits<uint8_t>::Maximum()) {
+			// no node found: move up the tree, pop key byte of current node
+			PopNode();
+			continue;
+		}
 
-		// the maximum key byte of the current node is less than the key
-		// fall back to the previous node
-		if (!child) {
+		top.byte++;
+		auto next_node = top.node.GetNextChild(*art, top.byte);
+		if (!next_node) {
 			PopNode();
-			return Next();
+			continue;
 		}
 
-		PushKey(node, top.byte);
-		node = *child;
+		current_key.Pop(1);
+		current_key.Push(top.byte);
 
-		// all children of this node qualify as greater or equal
-		depth++;
+		FindMinimum(*next_node);
+		return true;
 	}
+	return false;
+}
+
+void Iterator::PopNode() {
+	if (nodes.top().node.DecodeARTNodeType() == NType::PREFIX) {
+		auto prefix_byte_count = Prefix::Get(*art, nodes.top().node).data[Node::PREFIX_SIZE];
+		current_key.Pop(prefix_byte_count);
+	} else {
+		current_key.Pop(1);
+	}
+	nodes.pop();
 }
 
 } // namespace duckdb

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

@@ -1,15 +1,14 @@
 #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/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 ARTKey &key, const uint32_t depth, const row_t row_id) {
+Leaf &Leaf::New(ART &art, Node &node, const row_t row_id) {
 
 	node.SetPtr(Node::GetAllocator(art, NType::LEAF).New());
 	node.type = (uint8_t)NType::LEAF;
@@ -18,40 +17,24 @@ Leaf &Leaf::New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, c
 	// set the fields of the leaf
 	leaf.count = 1;
 	leaf.row_ids.inlined = row_id;
-
-	// initialize the prefix
-	D_ASSERT(key.len >= depth);
-	leaf.prefix.Initialize(art, key, depth, key.len - depth);
-
 	return leaf;
 }
 
-Leaf &Leaf::New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t *row_ids,
-                const idx_t count) {
+Leaf &Leaf::New(ART &art, Node &node, const row_t *row_ids, const idx_t count) {
 
-	// inlined leaf
-	D_ASSERT(count >= 1);
-	if (count == 1) {
-		return Leaf::New(art, node, key, depth, row_ids[0]);
-	}
+	D_ASSERT(count > 1);
 
 	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
+	// reset the count to copy the row IDs
 	leaf.count = 0;
-
-	// 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]);
 	}
 
-	// set the prefix
-	D_ASSERT(key.len >= depth);
-	leaf.prefix.Initialize(art, key, depth, key.len - depth);
-
 	return leaf;
 }
 
@@ -130,12 +113,7 @@ void Leaf::Merge(ART &art, Node &other) {
 
 void Leaf::Insert(ART &art, const row_t row_id) {
 
-	if (count == 0) {
-		row_ids.inlined = row_id;
-		count++;
-		return;
-	}
-
+	D_ASSERT(count != 0);
 	if (count == 1) {
 		MoveInlinedToSegment(art);
 	}
@@ -162,10 +140,7 @@ void Leaf::Remove(ART &art, const row_t row_id) {
 	// 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;
-		}
-
+		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;
@@ -176,9 +151,7 @@ void Leaf::Remove(ART &art, const row_t row_id) {
 	// 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;
-	}
+	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
@@ -303,7 +276,6 @@ BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
 	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);
@@ -336,7 +308,6 @@ BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
 void Leaf::Deserialize(ART &art, MetaBlockReader &reader) {
 
 	auto count_p = reader.Read<uint32_t>();
-	prefix.Deserialize(art, reader);
 
 	// inlined
 	if (count_p == 1) {