duckdb 0.8.2-dev87.0 → 0.9.0

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

@@ -8,85 +8,76 @@
 
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
 // classes
-class Node;
-class ARTKey;
-class MetaBlockWriter;
-class MetaBlockReader;
+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.
 class Leaf {
 public:
-	//! Number of row IDs
-	uint32_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
-	union {
-		//! The pointer to the head of the list of leaf segments
-		Node ptr;
-		//! Inlined row ID
-		row_t inlined;
-	} row_ids;
+	//! Delete copy constructors, as any Leaf can never own its memory
+	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;
 
 public:
-	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding one
-	//! row ID and a prefix starting at depth
-	static Leaf &New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t row_id);
-	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding
-	//! n_row_ids row IDs and a prefix starting at depth
-	static Leaf &New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t *row_ids,
-	                 const idx_t count);
-	//! Free the leaf
+	//! 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 reference to the leaf
-	static inline Leaf &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::LEAF).Get<Leaf>(ptr);
-	}
 
-	//! Initializes a merge by incrementing the buffer IDs of the leaf segments
-	void InitializeMerge(const ART &art, const idx_t buffer_count);
-	//! Merge leaves
-	void Merge(ART &art, Node &other);
+	//! 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);
 
 	//! Insert a row ID into a leaf
-	void Insert(ART &art, const row_t row_id);
-	//! Remove a row ID from a leaf
-	void Remove(ART &art, const row_t row_id);
-
-	//! Returns whether this leaf is inlined
-	inline bool IsInlined() const {
-		return count <= 1;
-	}
-	//! Get the row ID at the position
-	row_t GetRowId(const ART &art, const idx_t position) const;
-	//! Returns the position of a row ID, and an invalid index, if the leaf does not contain the row ID,
-	//! and sets the ptr to point to the segment containing the row ID
-	uint32_t FindRowId(const ART &art, Node &ptr, const row_t row_id) const;
+	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);
 
-	//! Returns the string representation of a leaf
-	string VerifyAndToString(const ART &art, const bool only_verify) const;
+	//! 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);
 
-	//! Serialize this leaf
-	BlockPointer Serialize(const ART &art, MetaBlockWriter &writer) const;
-	//! Deserialize this leaf
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	//! 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 segments of a leaf, if not inlined
-	void Vacuum(ART &art);
+	//! Vacuum the leaf (chain)
+	static void Vacuum(ART &art, Node &node);
 
 private:
-	//! Moves the inlined row ID onto a leaf segment, does not change the size
-	//! so this will be a (temporarily) invalid leaf
-	void MoveInlinedToSegment(ART &art);
+	//! 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);
 };
 
 } // namespace duckdb

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

@@ -1,48 +1,48 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/index/art/art_node.hpp
+// duckdb/execution/index/art/node.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
+#include "duckdb/common/assert.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/to_string.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/limits.hpp"
+#include "duckdb/execution/index/index_pointer.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 
 namespace duckdb {
 
 // classes
 enum class NType : uint8_t {
-	PREFIX_SEGMENT = 1,
-	LEAF_SEGMENT = 2,
-	LEAF = 3,
-	NODE_4 = 4,
-	NODE_16 = 5,
-	NODE_48 = 6,
-	NODE_256 = 7
+	PREFIX = 1,
+	LEAF = 2,
+	NODE_4 = 3,
+	NODE_16 = 4,
+	NODE_48 = 5,
+	NODE_256 = 6,
+	LEAF_INLINED = 7,
 };
+
 class ART;
-class Node;
 class Prefix;
-class MetaBlockReader;
-class MetaBlockWriter;
+class MetadataReader;
+class MetadataWriter;
 
 // structs
 struct BlockPointer;
 struct ARTFlags;
+struct MetaBlockPointer;
 
-//! The ARTNode is the swizzleable pointer class of the ART index.
-//! If the ARTNode pointer is not swizzled, then the leftmost byte identifies the NType.
-//! The remaining bytes are the position in the respective ART buffer.
-class Node : public SwizzleablePointer {
+//! The Node is the pointer class of the ART index.
+//! It inherits from the IndexPointer, and adds ART-specific functionality
+class Node : public IndexPointer {
 public:
-	// constants (this allows testing performance with different ART node sizes)
-
-	//! Node prefixes (NOTE: this should always hold: PREFIX_SEGMENT_SIZE >= PREFIX_INLINE_BYTES)
-	static constexpr uint32_t PREFIX_INLINE_BYTES = 8;
-	static constexpr uint32_t PREFIX_SEGMENT_SIZE = 32;
 	//! Node thresholds
 	static constexpr uint8_t NODE_48_SHRINK_THRESHOLD = 12;
 	static constexpr uint8_t NODE_256_SHRINK_THRESHOLD = 36;
@@ -53,68 +53,53 @@ public:
 	static constexpr uint16_t NODE_256_CAPACITY = 256;
 	//! Other constants
 	static constexpr uint8_t EMPTY_MARKER = 48;
-	static constexpr uint32_t LEAF_SEGMENT_SIZE = 8;
+	static constexpr uint8_t LEAF_SIZE = 4;
+	static constexpr uint8_t PREFIX_SIZE = 15;
+	static constexpr idx_t AND_ROW_ID = 0x00FFFFFFFFFFFFFF;
 
 public:
-	//! Constructs an empty ARTNode
-	Node();
-	//! Constructs a swizzled pointer from a block ID and an offset
-	explicit Node(MetaBlockReader &reader);
 	//! Get a new pointer to a node, might cause a new buffer allocation, and initialize it
 	static void New(ART &art, Node &node, const NType type);
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
 
-	inline bool operator==(const Node &node) const {
-		return swizzle_flag == node.swizzle_flag && type == node.type && offset == node.offset &&
-		       buffer_id == node.buffer_id;
+	//! Get references to the allocator
+	static FixedSizeAllocator &GetAllocator(const ART &art, const NType type);
+	//! Get a (immutable) reference to the node. If dirty is false, then T should be a const class
+	template <class NODE>
+	static inline const NODE &Ref(const ART &art, const Node ptr, const NType type) {
+		return *(GetAllocator(art, type).Get<const NODE>(ptr, false));
 	}
-
-	//! Retrieve the node type from the leftmost byte
-	inline NType DecodeARTNodeType() const {
-		D_ASSERT(!IsSwizzled());
-		D_ASSERT(type >= (uint8_t)NType::PREFIX_SEGMENT);
-		D_ASSERT(type <= (uint8_t)NType::NODE_256);
-		return NType(type);
+	//! Get a (const) reference to the node. If dirty is false, then T should be a const class
+	template <class NODE>
+	static inline NODE &RefMutable(const ART &art, const Node ptr, const NType type) {
+		return *(GetAllocator(art, type).Get<NODE>(ptr));
 	}
 
-	//! Set the pointer
-	inline void SetPtr(const SwizzleablePointer ptr) {
-		swizzle_flag = ptr.swizzle_flag;
-		type = ptr.type;
-		offset = ptr.offset;
-		buffer_id = ptr.buffer_id;
-	}
-
-	//! Replace the child node at the respective byte
-	void ReplaceChild(const ART &art, const uint8_t byte, const Node child);
+	//! Replace the child node at byte
+	void ReplaceChild(const ART &art, const uint8_t byte, const Node child) const;
 	//! Insert the child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child node at the respective byte
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+	//! Delete the child node at byte
+	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte);
 
+	//! Get the child (immutable) for the respective byte in the node
+	optional_ptr<const Node> GetChild(ART &art, const uint8_t byte) const;
 	//! Get the child for the respective byte in the node
-	optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
+	optional_ptr<Node> GetChildMutable(ART &art, const uint8_t byte) const;
+	//! Get the first child (immutable) that is greater or equal to the specific byte
+	optional_ptr<const Node> GetNextChild(ART &art, uint8_t &byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte, const bool deserialize = true) const;
-
-	//! Serialize the node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize the node
-	void Deserialize(ART &art);
+	optional_ptr<Node> GetNextChildMutable(ART &art, uint8_t &byte) const;
 
 	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
-	string VerifyAndToString(ART &art, const bool only_verify);
+	string VerifyAndToString(ART &art, const bool only_verify) const;
 	//! Returns the capacity of the node
 	idx_t GetCapacity() const;
-	//! Returns a pointer to the prefix of the node
-	Prefix &GetPrefix(ART &art);
 	//! Returns the matching node type for a given count
 	static NType GetARTNodeTypeByCount(const idx_t count);
-	//! Get references to the different allocators
-	static FixedSizeAllocator &GetAllocator(const ART &art, NType type);
 
-	//! Initializes a merge by fully deserializing the subtree of the node and incrementing its buffer IDs
+	//! Initializes a merge by incrementing the buffer IDs of a node and its subtree
 	void InitializeMerge(ART &art, const ARTFlags &flags);
 	//! Merge another node into this node
 	bool Merge(ART &art, Node &other);
@@ -124,7 +109,25 @@ public:
 	bool MergeInternal(ART &art, Node &other);
 
 	//! Vacuum all nodes that exceed their respective vacuum thresholds
-	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);
-};
+	void Vacuum(ART &art, const ARTFlags &flags);
 
+	//! Get the row ID (8th to 63rd bit)
+	inline row_t GetRowId() const {
+		return Get() & AND_ROW_ID;
+	}
+	//! Set the row ID (8th to 63rd bit)
+	inline void SetRowId(const row_t row_id) {
+		Set((Get() & AND_METADATA) | row_id);
+	}
+
+	//! Returns the type of the node, which is held in the metadata
+	inline NType GetType() const {
+		return NType(GetMetadata());
+	}
+
+	//! Assign operator
+	inline void operator=(const IndexPointer &ptr) {
+		Set(ptr.Get());
+	}
+};
 } // namespace duckdb

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

@@ -8,34 +8,32 @@
 
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-//! Node16 holds up to 16 ARTNode children sorted by their key byte
+//! Node16 holds up to 16 Node children sorted by their key byte
 class Node16 {
 public:
+	//! Delete copy constructors, as any Node16 can never own its memory
+	Node16(const Node16 &) = delete;
+	Node16 &operator=(const Node16 &) = delete;
+
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all partial key bytes
 	uint8_t key[Node::NODE_16_CAPACITY];
-	//! ART node pointers to the child nodes
+	//! Node pointers to the child nodes
 	Node children[Node::NODE_16_CAPACITY];
 
 public:
-	//! Get a new Node16 node, might cause a new buffer allocation, and initialize it
+	//! Get a new Node16, might cause a new buffer allocation, and initialize it
 	static Node16 &New(ART &art, Node &node);
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
-	//! Get a reference to the node
-	static inline Node16 &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::NODE_16).Get<Node16>(ptr);
-	}
+
 	//! Initializes all the fields of the node while growing a Node4 to a Node16
 	static Node16 &GrowNode4(ART &art, Node &node16, Node &node4);
 	//! Initializes all fields of the node while shrinking a Node48 to a Node16
@@ -46,21 +44,20 @@ public:
 
 	//! Insert a child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child node at the respective byte
+	//! Delete the child node at byte
 	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
 
-	//! Replace the child node at the respective byte
+	//! Replace the child node at byte
 	void ReplaceChild(const uint8_t byte, const Node child);
 
+	//! Get the (immutable) child for the respective byte in the node
+	optional_ptr<const Node> GetChild(const uint8_t byte) const;
 	//! Get the child for the respective byte in the node
-	optional_ptr<Node> GetChild(const uint8_t byte);
+	optional_ptr<Node> GetChildMutable(const uint8_t byte);
+	//! Get the first (immutable) child that is greater or equal to the specific byte
+	optional_ptr<const Node> GetNextChild(uint8_t &byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(uint8_t &byte);
-
-	//! Serialize an ART node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	optional_ptr<Node> GetNextChildMutable(uint8_t &byte);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,32 +8,30 @@
 
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-//! Node256 holds up to 256 ARTNode children which can be directly indexed by the key byte
+//! Node256 holds up to 256 Node children which can be directly indexed by the key byte
 class Node256 {
 public:
+	//! Delete copy constructors, as any Node256 can never own its memory
+	Node256(const Node256 &) = delete;
+	Node256 &operator=(const Node256 &) = delete;
+
 	//! Number of non-null children
 	uint16_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
-	//! ART node pointers to the child nodes
+	//! Node pointers to the child nodes
 	Node children[Node::NODE_256_CAPACITY];
 
 public:
-	//! Get a new Node256 node, might cause a new buffer allocation, and initialize it
+	//! Get a new Node256, might cause a new buffer allocation, and initialize it
 	static Node256 &New(ART &art, Node &node);
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
-	//! Get a reference to the node
-	static inline Node256 &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::NODE_256).Get<Node256>(ptr);
-	}
+
 	//! Initializes all the fields of the node while growing a Node48 to a Node256
 	static Node256 &GrowNode48(ART &art, Node &node256, Node &node48);
 
@@ -42,28 +40,22 @@ public:
 
 	//! Insert a child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child node at the respective byte
+	//! Delete the child node at byte
 	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
 
-	//! Replace the child node at the respective byte
+	//! Replace the child node at byte
 	inline void ReplaceChild(const uint8_t byte, const Node child) {
 		children[byte] = child;
 	}
 
+	//! Get the (immutable) child for the respective byte in the node
+	optional_ptr<const Node> GetChild(const uint8_t byte) const;
 	//! Get the child for the respective byte in the node
-	inline optional_ptr<Node> GetChild(const uint8_t byte) {
-		if (children[byte].IsSet()) {
-			return &children[byte];
-		}
-		return nullptr;
-	}
+	optional_ptr<Node> GetChildMutable(const uint8_t byte);
+	//! Get the first (immutable) child that is greater or equal to the specific byte
+	optional_ptr<const Node> GetNextChild(uint8_t &byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(uint8_t &byte);
-
-	//! Serialize an ART node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	optional_ptr<Node> GetNextChildMutable(uint8_t &byte);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,57 +8,54 @@
 
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-//! Node4 holds up to four ARTNode children sorted by their key byte
+//! Node4 holds up to four Node children sorted by their key byte
 class Node4 {
 public:
+	//! Delete copy constructors, as any Node4 can never own its memory
+	Node4(const Node4 &) = delete;
+	Node4 &operator=(const Node4 &) = delete;
+
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all partial key bytes
 	uint8_t key[Node::NODE_4_CAPACITY];
-	//! ART node pointers to the child nodes
+	//! Node pointers to the child nodes
 	Node children[Node::NODE_4_CAPACITY];
 
 public:
-	//! Get a new Node4 node, might cause a new buffer allocation, and initialize it
+	//! Get a new Node4, might cause a new buffer allocation, and initialize it
 	static Node4 &New(ART &art, Node &node);
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
-	//! Get a reference to the node
-	static inline Node4 &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::NODE_4).Get<Node4>(ptr);
-	}
+
 	//! Initializes all fields of the node while shrinking a Node16 to a Node4
 	static Node4 &ShrinkNode16(ART &art, Node &node4, Node &node16);
 
-	//! Initializes a merge by incrementing the buffer IDs of the node
+	//! Initializes a merge by incrementing the buffer IDs of the child nodes
 	void InitializeMerge(ART &art, const ARTFlags &flags);
 
 	//! Insert a child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child node at the respective byte
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+	//! Delete the child node at byte
+	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte);
 
-	//! Replace the child node at the respective byte
+	//! Replace the child node at byte
 	void ReplaceChild(const uint8_t byte, const Node child);
 
+	//! Get the (immutable) child for the respective byte in the node
+	optional_ptr<const Node> GetChild(const uint8_t byte) const;
 	//! Get the child for the respective byte in the node
-	optional_ptr<Node> GetChild(const uint8_t byte);
+	optional_ptr<Node> GetChildMutable(const uint8_t byte);
+	//! Get the first (immutable) child that is greater or equal to the specific byte
+	optional_ptr<const Node> GetNextChild(uint8_t &byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(uint8_t &byte);
-
-	//! Serialize an ART node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	optional_ptr<Node> GetNextChildMutable(uint8_t &byte);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,35 +8,33 @@
 
 #pragma once
 
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-//! Node48 holds up to 48 ARTNode children. It contains a child_index array which can be directly indexed by the key
+//! Node48 holds up to 48 Node children. It contains a child_index array which can be directly indexed by the key
 //! byte, and which contains the position of the child node in the children array
 class Node48 {
 public:
+	//! Delete copy constructors, as any Node48 can never own its memory
+	Node48(const Node48 &) = delete;
+	Node48 &operator=(const Node48 &) = delete;
+
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all possible partial key bytes, those not set have an EMPTY_MARKER
 	uint8_t child_index[Node::NODE_256_CAPACITY];
-	//! ART node pointers to the child nodes
+	//! Node pointers to the child nodes
 	Node children[Node::NODE_48_CAPACITY];
 
 public:
-	//! Get a new Node48 node, might cause a new buffer allocation, and initialize it
+	//! Get a new Node48, might cause a new buffer allocation, and initialize it
 	static Node48 &New(ART &art, Node &node);
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
-	//! Get a reference to the node
-	static inline Node48 &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::NODE_48).Get<Node48>(ptr);
-	}
+
 	//! Initializes all the fields of the node while growing a Node16 to a Node48
 	static Node48 &GrowNode16(ART &art, Node &node48, Node &node16);
 	//! Initializes all fields of the node while shrinking a Node256 to a Node48
@@ -47,30 +45,23 @@ public:
 
 	//! Insert a child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
-	//! Delete the child node at the respective byte
+	//! Delete the child node at byte
 	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
 
-	//! Replace the child node at the respective byte
+	//! Replace the child node at byte
 	inline void ReplaceChild(const uint8_t byte, const Node child) {
 		D_ASSERT(child_index[byte] != Node::EMPTY_MARKER);
 		children[child_index[byte]] = child;
 	}
 
+	//! Get the (immutable) child for the respective byte in the node
+	optional_ptr<const Node> GetChild(const uint8_t byte) const;
 	//! Get the child for the respective byte in the node
-	inline optional_ptr<Node> GetChild(const uint8_t byte) {
-		if (child_index[byte] != Node::EMPTY_MARKER) {
-			D_ASSERT(children[child_index[byte]].IsSet());
-			return &children[child_index[byte]];
-		}
-		return nullptr;
-	}
+	optional_ptr<Node> GetChildMutable(const uint8_t byte);
+	//! Get the first (immutable) child that is greater or equal to the specific byte
+	optional_ptr<const Node> GetNextChild(uint8_t &byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(uint8_t &byte);
-
-	//! Serialize an ART node
-	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
-	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	optional_ptr<Node> GetNextChildMutable(uint8_t &byte);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);