duckdb 0.8.2-dev4025.0 → 0.8.2-dev4142.0

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
 
@@ -28,6 +28,10 @@ struct BlockPointer;
 //! row ID directly in the node pointer.
 class Leaf {
 public:
+	//! 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
@@ -43,15 +47,10 @@ public:
 	static void New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t count);
 	//! 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) {
-		D_ASSERT(!ptr.IsSerialized());
-		return *Node::GetAllocator(art, NType::LEAF).Get<Leaf>(ptr);
-	}
 
 	//! Initializes a merge by incrementing the buffer IDs of the leaf (chain)
 	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
-	//! Merge leaves (chains) and free all copied leaf nodes
+	//! 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
@@ -60,19 +59,14 @@ public:
 	static bool Remove(ART &art, reference<Node> &node, const row_t row_id);
 
 	//! Get the total count of row IDs in the chain of leaves
-	static idx_t TotalCount(ART &art, Node &node);
+	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, Node &node, vector<row_t> &result_ids, idx_t 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, Node &node, const row_t row_id);
+	static bool ContainsRowId(ART &art, const Node &node, const row_t row_id);
 
 	//! Returns the string representation of the leaf (chain), or only traverses and verifies the leaf (chain)
-	static string VerifyAndToString(ART &art, Node &node);
-
-	//! Serialize the leaf (chain)
-	static BlockPointer Serialize(ART &art, Node &node, MetadataWriter &writer);
-	//! Deserialize the leaf (chain)
-	static void Deserialize(ART &art, Node &node, MetadataReader &reader);
+	static string VerifyAndToString(ART &art, const Node &node, const bool only_verify);
 
 	//! Vacuum the leaf (chain)
 	static void Vacuum(ART &art, Node &node);

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

@@ -13,6 +13,8 @@
 #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 {
 
@@ -26,7 +28,7 @@ enum class NType : uint8_t {
 	NODE_256 = 6,
 	LEAF_INLINED = 7,
 };
-class FixedSizeAllocator;
+
 class ART;
 class Prefix;
 class MetadataReader;
@@ -38,9 +40,8 @@ struct ARTFlags;
 struct MetaBlockPointer;
 
 //! The Node is the pointer class of the ART index.
-//! If the node is serialized, then the pointer points to a storage address (and has no type),
-//! otherwise the pointer has a type and stores other information (e.g., a buffer location or a row ID).
-class Node {
+//! It inherits from the IndexPointer, and adds ART-specific functionality
+class Node : public IndexPointer {
 public:
 	//! Node thresholds
 	static constexpr uint8_t NODE_48_SHRINK_THRESHOLD = 12;
@@ -50,33 +51,11 @@ public:
 	static constexpr uint8_t NODE_16_CAPACITY = 16;
 	static constexpr uint8_t NODE_48_CAPACITY = 48;
 	static constexpr uint16_t NODE_256_CAPACITY = 256;
-	//! Bit-shifting
-	static constexpr uint64_t SHIFT_OFFSET = 32;
-	static constexpr uint64_t SHIFT_TYPE = 56;
-	static constexpr uint64_t SHIFT_SERIALIZED_FLAG = 63;
-	//! AND operations
-	static constexpr uint64_t AND_OFFSET = 0x0000000000FFFFFF;
-	static constexpr uint64_t AND_BUFFER_ID = 0x00000000FFFFFFFF;
-	static constexpr uint64_t AND_IS_SET = 0xFF00000000000000;
-	static constexpr uint64_t AND_RESET = 0x00FFFFFFFFFFFFFF;
-	//! OR operations
-	static constexpr uint64_t SET_SERIALIZED_FLAG = 0x8000000000000000;
 	//! Other constants
 	static constexpr uint8_t EMPTY_MARKER = 48;
 	static constexpr uint8_t LEAF_SIZE = 4;
 	static constexpr uint8_t PREFIX_SIZE = 15;
-
-public:
-	//! Constructors
-
-	//! Constructs an empty Node
-	Node() : data(0) {};
-	//! Constructs a serialized Node pointer from a block ID and an offset
-	explicit Node(MetadataReader &reader);
-	//! Constructs an in-memory Node from a buffer ID and an offset
-	Node(const uint32_t buffer_id, const uint32_t offset) : data(0) {
-		SetPtr(buffer_id, offset);
-	};
+	static constexpr idx_t AND_ROW_ID = 0x00FFFFFFFFFFFFFF;
 
 public:
 	//! Get a new pointer to a node, might cause a new buffer allocation, and initialize it
@@ -84,33 +63,43 @@ public:
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
 
-	//! Replace the child node at the respective byte
-	void ReplaceChild(const ART &art, const uint8_t byte, const Node child);
+	//! 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));
+	}
+	//! 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));
+	}
+
+	//! 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
+	//! 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, MetadataWriter &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 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);
@@ -122,90 +111,23 @@ public:
 	//! Vacuum all nodes that exceed their respective vacuum thresholds
 	void Vacuum(ART &art, const ARTFlags &flags);
 
-	// Getters and Setters
-
-	//! Returns whether the node is serialized or not (zero bit)
-	inline bool IsSerialized() const {
-		return data >> Node::SHIFT_SERIALIZED_FLAG;
-	}
-	//! Get the type (1st to 7th bit)
-	inline NType GetType() const {
-		D_ASSERT(!IsSerialized());
-		auto type = data >> Node::SHIFT_TYPE;
-		D_ASSERT(type >= (uint8_t)NType::PREFIX);
-		D_ASSERT(type <= (uint8_t)NType::LEAF_INLINED);
-		return NType(type);
-	}
-	//! Get the offset (8th to 23rd bit)
-	inline idx_t GetOffset() const {
-		auto offset = data >> Node::SHIFT_OFFSET;
-		return offset & Node::AND_OFFSET;
-	}
-	//! Get the block/buffer ID (24th to 63rd bit)
-	inline idx_t GetBufferId() const {
-		return data & Node::AND_BUFFER_ID;
-	}
 	//! Get the row ID (8th to 63rd bit)
 	inline row_t GetRowId() const {
-		return data & Node::AND_RESET;
-	}
-
-	//! Set the serialized flag (zero bit)
-	inline void SetSerialized() {
-		data &= Node::AND_RESET;
-		data |= Node::SET_SERIALIZED_FLAG;
-	}
-	//! Set the type (1st to 7th bit)
-	inline void SetType(const uint8_t type) {
-		D_ASSERT(!IsSerialized());
-		data += (uint64_t)type << Node::SHIFT_TYPE;
-	}
-	//! Set the block/buffer ID (24th to 63rd bit) and offset (8th to 23rd bit)
-	inline void SetPtr(const uint32_t buffer_id, const uint32_t offset) {
-		D_ASSERT(!(data & Node::AND_RESET));
-		auto shifted_offset = ((uint64_t)offset) << Node::SHIFT_OFFSET;
-		data += shifted_offset;
-		data += buffer_id;
+		return Get() & AND_ROW_ID;
 	}
 	//! Set the row ID (8th to 63rd bit)
 	inline void SetRowId(const row_t row_id) {
-		D_ASSERT(!(data & Node::AND_RESET));
-		data += row_id;
-	}
-
-	//! Returns true, if neither the serialized flag is set nor the type
-	inline bool IsSet() const {
-		return data & Node::AND_IS_SET;
-	}
-	//! Reset the Node pointer by setting the node info to zero
-	inline void Reset() {
-		data = 0;
+		Set((Get() & AND_METADATA) | row_id);
 	}
 
-	//! Adds an idx_t to a buffer ID, the rightmost 32 bits contain the buffer ID
-	inline void AddToBufferID(const idx_t summand) {
-		D_ASSERT(summand < NumericLimits<uint32_t>().Maximum());
-		data += summand;
+	//! Returns the type of the node, which is held in the metadata
+	inline NType GetType() const {
+		return NType(GetMetadata());
 	}
 
-	//! Comparison operator
-	inline bool operator==(const Node &node) const {
-		return data == node.data;
+	//! Assign operator
+	inline void operator=(const IndexPointer &ptr) {
+		Set(ptr.Get());
 	}
-
-private:
-	//! Data holds all the information contained in a Node pointer
-	//! [0: serialized flag, 1 - 7: type,
-	//! 8 - 23: offset, 24 - 63: buffer/block ID OR
-	//! 8 - 63: row ID]
-	//! NOTE: a Node pointer can be either serialized OR have a type
-	//! NOTE: we do not use bit fields because when using bit fields Windows compiles
-	//! the Node class into 16 bytes instead of the intended 8 bytes, doubling the
-	//! space requirements
-	//! https://learn.microsoft.com/en-us/cpp/cpp/cpp-bit-fields?view=msvc-170
-	uint64_t data;
 };
-
-static_assert(sizeof(Node) == sizeof(uint64_t), "Invalid size for Node type.");
-
 } // namespace duckdb

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

@@ -8,32 +8,32 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.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;
 	//! 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) {
-		D_ASSERT(!ptr.IsSerialized());
-		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
@@ -44,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 this node
-	BlockPointer Serialize(ART &art, MetadataWriter &writer);
-	//! Deserialize this node
-	void Deserialize(MetadataReader &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,30 +8,30 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.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;
-	//! 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) {
-		D_ASSERT(!ptr.IsSerialized());
-		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);
 
@@ -40,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 this node
-	BlockPointer Serialize(ART &art, MetadataWriter &writer);
-	//! Deserialize this node
-	void Deserialize(MetadataReader &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,32 +8,32 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.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;
 	//! 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) {
-		D_ASSERT(!ptr.IsSerialized());
-		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);
 
@@ -42,21 +42,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, 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 this node
-	BlockPointer Serialize(ART &art, MetadataWriter &writer);
-	//! Deserialize this node
-	void Deserialize(MetadataReader &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,33 +8,33 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.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;
 	//! 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) {
-		D_ASSERT(!ptr.IsSerialized());
-		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
@@ -45,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 this node
-	BlockPointer Serialize(ART &art, MetadataWriter &writer);
-	//! Deserialize this node
-	void Deserialize(MetadataReader &reader);
+	optional_ptr<Node> GetNextChildMutable(uint8_t &byte);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);