duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -72,17 +72,6 @@ bool ARTKey::operator>(const ARTKey &k) const {
 	return len > k.len;
 }
 
-bool ARTKey::operator<(const ARTKey &k) const {
-	for (uint32_t i = 0; i < MinValue<uint32_t>(len, k.len); i++) {
-		if (data[i] < k.data[i]) {
-			return true;
-		} else if (data[i] > k.data[i]) {
-			return false;
-		}
-	}
-	return len < k.len;
-}
-
 bool ARTKey::operator>=(const ARTKey &k) const {
 	for (uint32_t i = 0; i < MinValue<uint32_t>(len, k.len); i++) {
 		if (data[i] > k.data[i]) {

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

@@ -1,9 +1,5 @@
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-
 namespace duckdb {
 
 constexpr idx_t FixedSizeAllocator::BASE[];
@@ -46,7 +42,7 @@ FixedSizeAllocator::~FixedSizeAllocator() {
 	}
 }
 
-SwizzleablePointer FixedSizeAllocator::New() {
+Node FixedSizeAllocator::New() {
 
 	// no more free pointers
 	if (buffers_with_free_space.empty()) {
@@ -77,19 +73,19 @@ SwizzleablePointer FixedSizeAllocator::New() {
 		buffers_with_free_space.erase(buffer_id);
 	}
 
-	return SwizzleablePointer(offset, buffer_id);
+	return Node(buffer_id, offset);
 }
 
-void FixedSizeAllocator::Free(const SwizzleablePointer ptr) {
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.buffer_id].ptr);
+void FixedSizeAllocator::Free(const Node ptr) {
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.GetBufferId()].ptr);
 	ValidityMask mask(bitmask_ptr);
-	D_ASSERT(!mask.RowIsValid(ptr.offset));
-	mask.SetValid(ptr.offset);
-	buffers_with_free_space.insert(ptr.buffer_id);
+	D_ASSERT(!mask.RowIsValid(ptr.GetOffset()));
+	mask.SetValid(ptr.GetOffset());
+	buffers_with_free_space.insert(ptr.GetBufferId());
 
 	D_ASSERT(total_allocations > 0);
-	D_ASSERT(buffers[ptr.buffer_id].allocation_count > 0);
-	buffers[ptr.buffer_id].allocation_count--;
+	D_ASSERT(buffers[ptr.GetBufferId()].allocation_count > 0);
+	buffers[ptr.GetBufferId()].allocation_count--;
 	total_allocations--;
 }
 
@@ -114,7 +110,7 @@ void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
 	}
 	other.buffers.clear();
 
-	// merge the vectors containing all buffers with free space
+	// merge the buffers with free spaces
 	for (auto &buffer_id : other.buffers_with_free_space) {
 		buffers_with_free_space.insert(buffer_id + buffer_count);
 	}
@@ -172,7 +168,7 @@ void FixedSizeAllocator::FinalizeVacuum() {
 	}
 }
 
-SwizzleablePointer FixedSizeAllocator::VacuumPointer(const SwizzleablePointer ptr) {
+Node FixedSizeAllocator::VacuumPointer(const Node ptr) {
 
 	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
 	// buffer after the vacuum operation

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

@@ -7,121 +7,62 @@
 
 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
-		if (result_ids.size() + last_leaf->count > max_count) {
+		// copy all row IDs of this leaf into the result IDs (if they don't exceed max_count)
+		if (!Leaf::GetRowIds(*art, last_leaf, result_ids, 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(*art, i);
-			result_ids.push_back(row_id);
-		}
-
 		// get the next leaf
 		has_next = Next();
 
@@ -130,172 +71,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.IsSerialized()) {
+		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.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
+		last_leaf = node;
+		return;
+	}
 
-			// no node found: move up the tree, pop prefix and key of current node
-			PopNode();
+	// traverse the prefix
+	if (node.GetType() == 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.IsSerialized()) {
+		node.Deserialize(*art);
+	}
 
-		nodes.emplace(node, 0);
-		auto &top = nodes.top();
+	// we found the lower bound
+	if (node.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
+		if (!equal && current_key == key) {
+			return Next();
+		}
+		last_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.GetType() != 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.GetType() != NType::LEAF && top.node.GetType() != NType::LEAF_INLINED);
+
+		if (top.node.GetType() == 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.GetType() == 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