duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/include/duckdb/execution/index/art/base_leaf.hpp

@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/base_leaf.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+
+namespace duckdb {
+
+template <uint8_t CAPACITY, NType TYPE>
+class BaseLeaf {
+	friend class Node7Leaf;
+	friend class Node15Leaf;
+	friend class Node256Leaf;
+
+public:
+	BaseLeaf() = delete;
+	BaseLeaf(const BaseLeaf &) = delete;
+	BaseLeaf &operator=(const BaseLeaf &) = delete;
+
+private:
+	uint8_t count;
+	uint8_t key[CAPACITY];
+
+public:
+	//! Get a new BaseLeaf and initialize it.
+	static BaseLeaf &New(ART &art, Node &node) {
+		node = Node::GetAllocator(art, TYPE).New();
+		node.SetMetadata(static_cast<uint8_t>(TYPE));
+
+		auto &n = Node::Ref<BaseLeaf>(art, node, TYPE);
+		n.count = 0;
+		return n;
+	}
+
+	//! Returns true, if the byte exists, else false.
+	bool HasByte(uint8_t &byte) const {
+		for (uint8_t i = 0; i < count; i++) {
+			if (key[i] == byte) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	//! Get the first byte greater than or equal to the byte.
+	//! Returns true, if such a byte exists, else false.
+	bool GetNextByte(uint8_t &byte) const {
+		for (uint8_t i = 0; i < count; i++) {
+			if (key[i] >= byte) {
+				byte = key[i];
+				return true;
+			}
+		}
+		return false;
+	}
+
+private:
+	static void InsertByteInternal(BaseLeaf &n, const uint8_t byte);
+	static BaseLeaf &DeleteByteInternal(ART &art, Node &node, const uint8_t byte);
+};
+
+//! Node7Leaf holds up to seven sorted bytes.
+class Node7Leaf : public BaseLeaf<7, NType::NODE_7_LEAF> {
+	friend class Node15Leaf;
+
+public:
+	static constexpr NType NODE_7_LEAF = NType::NODE_7_LEAF;
+	static constexpr uint8_t CAPACITY = 7;
+	static constexpr idx_t AND_LAST_BYTE = 0xFFFFFFFFFFFFFF00;
+
+public:
+	//! Insert a byte.
+	static void InsertByte(ART &art, Node &node, const uint8_t byte);
+	//! Delete a byte.
+	static void DeleteByte(ART &art, Node &node, Node &prefix, const uint8_t byte, const ARTKey &row_id);
+
+private:
+	static void ShrinkNode15Leaf(ART &art, Node &node7_leaf, Node &node15_leaf);
+};
+
+//! Node15Leaf holds up to 15 sorted bytes.
+class Node15Leaf : public BaseLeaf<15, NType::NODE_15_LEAF> {
+	friend class Node7Leaf;
+	friend class Node256Leaf;
+
+public:
+	static constexpr NType NODE_15_LEAF = NType::NODE_15_LEAF;
+	static constexpr uint8_t CAPACITY = 15;
+
+public:
+	//! Insert a byte.
+	static void InsertByte(ART &art, Node &node, const uint8_t byte);
+	//! Delete a byte.
+	static void DeleteByte(ART &art, Node &node, const uint8_t byte);
+
+private:
+	static void GrowNode7Leaf(ART &art, Node &node15_leaf, Node &node7_leaf);
+	static void ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_leaf);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/base_node.hpp

@@ -0,0 +1,140 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/base_node.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+
+namespace duckdb {
+
+template <uint8_t CAPACITY, NType TYPE>
+class BaseNode {
+	friend class Node4;
+	friend class Node16;
+	friend class Node48;
+
+public:
+	BaseNode() = delete;
+	BaseNode(const BaseNode &) = delete;
+	BaseNode &operator=(const BaseNode &) = delete;
+
+private:
+	uint8_t count;
+	uint8_t key[CAPACITY];
+	Node children[CAPACITY];
+
+public:
+	//! Get a new BaseNode and initialize it.
+	static BaseNode &New(ART &art, Node &node) {
+		node = Node::GetAllocator(art, TYPE).New();
+		node.SetMetadata(static_cast<uint8_t>(TYPE));
+
+		auto &n = Node::Ref<BaseNode>(art, node, TYPE);
+		n.count = 0;
+		return n;
+	}
+
+	//! Free the node and its children.
+	static void Free(ART &art, Node &node) {
+		auto &n = Node::Ref<BaseNode>(art, node, TYPE);
+		for (uint8_t i = 0; i < n.count; i++) {
+			Node::Free(art, n.children[i]);
+		}
+	}
+
+	//! Replace the child at byte.
+	static void ReplaceChild(BaseNode &n, const uint8_t byte, const Node child) {
+		D_ASSERT(n.count != 0);
+		for (uint8_t i = 0; i < n.count; i++) {
+			if (n.key[i] == byte) {
+				auto status = n.children[i].GetGateStatus();
+				n.children[i] = child;
+
+				if (status == GateStatus::GATE_SET && child.HasMetadata()) {
+					n.children[i].SetGateStatus(status);
+				}
+				return;
+			}
+		}
+	}
+
+	//! Get the child at byte.
+	static unsafe_optional_ptr<Node> GetChild(BaseNode &n, const uint8_t byte) {
+		for (uint8_t i = 0; i < n.count; i++) {
+			if (n.key[i] == byte) {
+				D_ASSERT(n.children[i].HasMetadata());
+				return &n.children[i];
+			}
+		}
+		return nullptr;
+	}
+
+	//! Get the first child greater than or equal to the byte.
+	static unsafe_optional_ptr<Node> GetNextChild(BaseNode &n, uint8_t &byte) {
+		for (uint8_t i = 0; i < n.count; i++) {
+			if (n.key[i] >= byte) {
+				byte = n.key[i];
+				return &n.children[i];
+			}
+		}
+		return nullptr;
+	}
+
+public:
+	template <class F>
+	static void Iterator(BaseNode<CAPACITY, TYPE> &n, F &&lambda) {
+		for (uint8_t i = 0; i < n.count; i++) {
+			lambda(n.children[i]);
+		}
+	}
+
+private:
+	static void InsertChildInternal(BaseNode &n, const uint8_t byte, const Node child);
+	static BaseNode &DeleteChildInternal(ART &art, Node &node, const uint8_t byte);
+};
+
+//! Node4 holds up to four children sorted by their key byte.
+class Node4 : public BaseNode<4, NType::NODE_4> {
+	friend class Node16;
+
+public:
+	static constexpr NType NODE_4 = NType::NODE_4;
+	static constexpr uint8_t CAPACITY = 4;
+
+public:
+	//! Insert a child at byte.
+	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
+	//! Delete the child at byte.
+	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte, const GateStatus status);
+
+private:
+	static void ShrinkNode16(ART &art, Node &node4, Node &node16);
+};
+
+class Node16 : public BaseNode<16, NType::NODE_16> {
+	friend class Node4;
+	friend class Node48;
+
+public:
+	static constexpr NType NODE_16 = NType::NODE_16;
+	static constexpr uint8_t CAPACITY = 16;
+
+public:
+	//! Insert a child at byte.
+	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
+	//! Delete the child at byte.
+	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+
+private:
+	static void GrowNode4(ART &art, Node &node16, Node &node4);
+	static void ShrinkNode48(ART &art, Node &node16, Node &node48);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/iterator.hpp

@@ -14,7 +14,7 @@
 
 namespace duckdb {
 
-//! Keeps track of the byte leading to the currently active child of the node
+//! Keeps track of the byte leading to the currently active child of the node.
 struct IteratorEntry {
 	IteratorEntry(Node node, uint8_t byte) : node(node), byte(byte) {
 	}
@@ -23,60 +23,79 @@ struct IteratorEntry {
 	uint8_t byte = 0;
 };
 
-//! Keeps track of the current key in the iterator leading down to the top node in the stack
+//! Keeps track of the current key in the iterator leading down to the top node in the stack.
 class IteratorKey {
 public:
-	//! Pushes a byte into the current key
+	//! Pushes a byte into the current key.
 	inline void Push(const uint8_t key_byte) {
 		key_bytes.push_back(key_byte);
 	}
-	//! Pops n bytes from the current key
+	//! Pops n bytes from the current key.
 	inline void Pop(const idx_t n) {
 		key_bytes.resize(key_bytes.size() - n);
 	}
-
-	//! Subscript operator
+	//! Returns the byte at idx.
 	inline uint8_t &operator[](idx_t idx) {
 		D_ASSERT(idx < key_bytes.size());
 		return key_bytes[idx];
 	}
-	//! Greater than operator
-	bool operator>(const ARTKey &key) const;
-	//! Greater than or equal to operator
-	bool operator>=(const ARTKey &key) const;
-	//! Equal to operator
-	bool operator==(const ARTKey &key) const;
+	// Returns the number of key bytes.
+	inline idx_t Size() const {
+		return key_bytes.size();
+	}
+
+	//! Returns true, if key_bytes contains all bytes of key.
+	bool Contains(const ARTKey &key) const;
+	//! Returns true, if key_bytes is greater than [or equal to] the key.
+	bool GreaterThan(const ARTKey &key, const bool equal, const uint8_t nested_depth) const;
 
 private:
-	vector<uint8_t> key_bytes;
+	unsafe_vector<uint8_t> key_bytes;
 };
 
 class Iterator {
 public:
-	//! Holds the current key leading down to the top node on the stack
+	static constexpr uint8_t ROW_ID_SIZE = sizeof(row_t);
+
+public:
+	explicit Iterator(ART &art) : art(art), status(GateStatus::GATE_NOT_SET) {};
+	//! Holds the current key leading down to the top node on the stack.
 	IteratorKey current_key;
-	//! Pointer to the ART
-	optional_ptr<ART> art = nullptr;
 
+public:
 	//! Scans the tree, starting at the current top node on the stack, and ending at upper_bound.
-	//! If upper_bound is the empty ARTKey, than there is no upper bound
-	bool Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row_t> &result_ids, const bool equal);
-	//! Finds the minimum (leaf) of the current subtree
+	//! If upper_bound is the empty ARTKey, than there is no upper bound.
+	bool Scan(const ARTKey &upper_bound, const idx_t max_count, unsafe_vector<row_t> &row_ids, const bool equal);
+	//! Finds the minimum (leaf) of the current subtree.
 	void FindMinimum(const Node &node);
 	//! Finds the lower bound of the ART and adds the nodes to the stack. Returns false, if the lower
-	//! bound exceeds the maximum value of the ART
+	//! bound exceeds the maximum value of the ART.
 	bool LowerBound(const Node &node, const ARTKey &key, const bool equal, idx_t depth);
 
+	//! Returns the nested depth.
+	uint8_t GetNestedDepth() const {
+		return nested_depth;
+	}
+
 private:
-	//! Stack of nodes from the root to the currently active node
+	//! The ART.
+	ART &art;
+	//! Stack of nodes from the root to the currently active node.
 	stack<IteratorEntry> nodes;
-	//! Last visited leaf node
+	//! Last visited leaf node.
 	Node last_leaf = Node();
+	//! Holds the row ID of nested leaves.
+	uint8_t row_id[ROW_ID_SIZE];
+	//! True, if we passed a gate.
+	GateStatus status;
+	//! Depth in a nested leaf.
+	uint8_t nested_depth = 0;
 
+private:
 	//! Goes to the next leaf in the ART and sets it as last_leaf,
-	//! returns false if there is no next leaf
+	//! returns false if there is no next leaf.
 	bool Next();
-	//! Pop the top node from the stack of iterator entries and adjust the current key
+	//! Pop the top node from the stack of iterator entries and adjust the current key.
 	void PopNode();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp

@@ -14,70 +14,59 @@
 
 namespace duckdb {
 
-// classes
-class MetadataWriter;
-class MetadataReader;
-
-// structs
-struct BlockPointer;
-
-//! The LEAF is a special node type that contains a count, up to LEAF_SIZE row IDs,
-//! and a Node pointer. If this pointer is set, then it must point to another LEAF,
-//! creating a chain of leaf nodes storing row IDs.
-//! This class also contains functionality for nodes of type LEAF_INLINED, in which case we store the
-//! row ID directly in the node pointer.
+//! There are three types of leaves.
+//! 1. LEAF_INLINED: Inlines a row ID in a Node pointer.
+//! 2. LEAF: Deprecated. A list of Leaf nodes containing row IDs.
+//! 3. Nested leaves indicated by gate nodes. If an ART key contains multiple row IDs, then we use the row IDs as keys
+//! and create a nested ART behind the gate node. As row IDs are always unique, these nested ARTs never contain
+//! duplicates themselves.
 class Leaf {
 public:
-	//! Delete copy constructors, as any Leaf can never own its memory
+	static constexpr NType LEAF = NType::LEAF;
+	static constexpr NType INLINED = NType::LEAF_INLINED;
+	static constexpr uint8_t LEAF_SIZE = 4; // Deprecated.
+
+public:
+	Leaf() = delete;
 	Leaf(const Leaf &) = delete;
 	Leaf &operator=(const Leaf &) = delete;
 
-	//! The number of row IDs in this leaf
-	uint8_t count;
-	//! Up to LEAF_SIZE row IDs
-	row_t row_ids[Node::LEAF_SIZE];
-	//! A pointer to the next LEAF node
-	Node ptr;
+private:
+	uint8_t count;            // Deprecated.
+	row_t row_ids[LEAF_SIZE]; // Deprecated.
+	Node ptr;                 // Deprecated.
 
 public:
-	//! Inline a row ID into a node pointer
+	//! Inline a row ID into a node pointer.
 	static void New(Node &node, const row_t row_id);
-	//! Get a new chain of leaf nodes, might cause new buffer allocations,
-	//! with the node parameter holding the tail of the chain
-	static void New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t count);
-	//! Get a new leaf node without any data
-	static Leaf &New(ART &art, Node &node);
-	//! Free the leaf (chain)
-	static void Free(ART &art, Node &node);
+	//! Get a new non-inlined nested leaf node.
+	static void New(ART &art, reference<Node> &node, const unsafe_vector<ARTKey> &row_ids, const idx_t start,
+	                const idx_t count);
 
-	//! Initializes a merge by incrementing the buffer IDs of the leaf (chain)
-	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
-	//! Merge leaf (chains) and free all copied leaf nodes
-	static void Merge(ART &art, Node &l_node, Node &r_node);
+	//! Merge two leaves. r_node must be INLINED.
+	static void MergeInlined(ART &art, Node &l_node, Node &r_node);
 
-	//! Insert a row ID into a leaf
-	static void Insert(ART &art, Node &node, const row_t row_id);
-	//! Remove a row ID from a leaf. Returns true, if the leaf is empty after the removal
-	static bool Remove(ART &art, reference<Node> &node, const row_t row_id);
+	//! Insert a row ID into an inlined leaf.
+	static void InsertIntoInlined(ART &art, Node &node, const ARTKey &row_id, idx_t depth, const GateStatus status);
 
-	//! Get the total count of row IDs in the chain of leaves
-	static idx_t TotalCount(ART &art, const Node &node);
-	//! Fill the result_ids vector with the row IDs of this leaf chain, if the total count does not exceed max_count
-	static bool GetRowIds(ART &art, const Node &node, vector<row_t> &result_ids, const idx_t max_count);
-	//! Returns whether the leaf contains the row ID
-	static bool ContainsRowId(ART &art, const Node &node, const row_t row_id);
+	//! Transforms a deprecated leaf to a nested leaf.
+	static void TransformToNested(ART &art, Node &node);
+	//! Transforms a nested leaf to a deprecated leaf.
+	static void TransformToDeprecated(ART &art, Node &node);
 
-	//! Returns the string representation of the leaf (chain), or only traverses and verifies the leaf (chain)
-	static string VerifyAndToString(ART &art, const Node &node, const bool only_verify);
-
-	//! Vacuum the leaf (chain)
-	static void Vacuum(ART &art, Node &node);
-
-private:
-	//! Moves the inlined row ID onto a leaf
-	static void MoveInlinedToLeaf(ART &art, Node &node);
-	//! Appends the row ID to this leaf, or creates a subsequent leaf, if this node is full
-	Leaf &Append(ART &art, const row_t row_id);
+public:
+	//! Frees the linked list of leaves.
+	static void DeprecatedFree(ART &art, Node &node);
+	//! Fills the row_ids vector with the row IDs of this linked list of leaves.
+	//! Never pushes more than max_count row IDs.
+	static bool DeprecatedGetRowIds(ART &art, const Node &node, unsafe_vector<row_t> &row_ids, const idx_t max_count);
+	//! Vacuums the linked list of leaves.
+	static void DeprecatedVacuum(ART &art, Node &node);
+	//! Returns the string representation of the linked list of leaves, if only_verify is true.
+	//! Else, it traverses and verifies the linked list of leaves.
+	static string DeprecatedVerifyAndToString(ART &art, const Node &node, const bool only_verify);
+	//! Count the number of leaves.
+	void DeprecatedVerifyAllocations(ART &art, unordered_map<uint8_t, idx_t> &node_counts) const;
 };
 
 } // namespace duckdb