duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp

@@ -42,16 +42,19 @@ class GroupedAggregateHashTable : public BaseAggregateHashTable {
 public:
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
 	                          vector<LogicalType> payload_types, const vector<BoundAggregateExpression *> &aggregates,
-	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0);
+	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0,
+	                          TupleDataValidityType group_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES);
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
 	                          vector<LogicalType> payload_types, vector<AggregateObject> aggregates,
-	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0);
-	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types);
+	                          idx_t initial_capacity = InitialCapacity(), idx_t radix_bits = 0,
+	                          TupleDataValidityType group_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES);
+	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types,
+	                          TupleDataValidityType group_validity = TupleDataValidityType::CAN_HAVE_NULL_VALUES);
 	~GroupedAggregateHashTable() override;
 
 public:
 	//! The hash table load factor, when a resize is triggered
-	constexpr static double LOAD_FACTOR = 1.25;
+	constexpr static double LOAD_FACTOR = 1.5;
 
 	//! Get the layout of this HT
 	shared_ptr<TupleDataLayout> GetLayoutPtr();
@@ -189,10 +192,9 @@ private:
 		Vector hashes;
 		Vector ht_offsets;
 		Vector hash_salts;
+		SelectionVector new_groups;
 		SelectionVector group_compare_vector;
 		SelectionVector no_match_vector;
-		SelectionVector empty_vector;
-		SelectionVector new_groups;
 		Vector addresses;
 		DataChunk group_chunk;
 		AggregateDictionaryState dict_state;

package/src/duckdb/src/include/duckdb/execution/executor.hpp

@@ -52,7 +52,6 @@ public:
 	static Executor &Get(ClientContext &context);
 
 	void Initialize(PhysicalOperator &physical_plan);
-	void Initialize(unique_ptr<PhysicalOperator> physical_plan);
 
 	void CancelTasks();
 	PendingExecutionResult ExecuteTask(bool dry_run = false);
@@ -148,7 +147,6 @@ private:
 
 private:
 	optional_ptr<PhysicalOperator> physical_plan;
-	unique_ptr<PhysicalOperator> owned_plan;
 
 	mutex executor_lock;
 	//! All pipelines of the query plan

package/src/duckdb/src/include/duckdb/execution/expression_executor.hpp

@@ -67,6 +67,10 @@ public:
 	DUCKDB_API idx_t SelectExpression(DataChunk &input, SelectionVector &result_sel,
 	                                  optional_ptr<SelectionVector> current_sel, idx_t current_count);
 
+	DUCKDB_API idx_t SelectExpression(DataChunk &input, optional_ptr<SelectionVector> true_sel,
+	                                  optional_ptr<SelectionVector> false_sel,
+	                                  optional_ptr<SelectionVector> current_sel, idx_t current_count);
+
 	//! Execute the expression with index `expr_idx` and store the result in the result vector
 	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result);
 	//! Evaluate a scalar expression and fold it into a single value

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -13,7 +13,9 @@
 #include "duckdb/function/function.hpp"
 
 namespace duckdb {
+
 class Expression;
+class BoundFunctionExpression;
 class ExpressionExecutor;
 struct ExpressionExecutorState;
 struct FunctionLocalState;
@@ -53,15 +55,32 @@ public:
 };
 
 struct ExecuteFunctionState : public ExpressionState {
+public:
 	ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root);
 	~ExecuteFunctionState() override;
 
-	unique_ptr<FunctionLocalState> local_state;
-
 public:
 	static optional_ptr<FunctionLocalState> GetFunctionState(ExpressionState &state) {
 		return state.Cast<ExecuteFunctionState>().local_state.get();
 	}
+
+	bool TryExecuteDictionaryExpression(const BoundFunctionExpression &expr, DataChunk &args, ExpressionState &state,
+	                                    Vector &result);
+
+public:
+	unique_ptr<FunctionLocalState> local_state;
+
+private:
+	//! The column index of the "unary" input column that may be a dictionary vector
+	//! Only valid when the expression is eligible for the dictionary expression optimization
+	//! This is the case when the input is "practically unary", i.e., only one non-const input column
+	optional_idx input_col_idx;
+	//! Storage ID of the input dictionary vector
+	string current_input_dictionary_id;
+	//! Vector holding the expression executed on the entire dictionary
+	unique_ptr<Vector> output_dictionary;
+	//! ID of the output dictionary_vector
+	string output_dictionary_id;
 };
 
 struct ExpressionExecutorState {

package/src/duckdb/src/include/duckdb/execution/ht_entry.hpp

@@ -79,6 +79,10 @@ public:
 		return ExtractSalt(value);
 	}
 
+	inline hash_t GetSaltWithNulls() const {
+		return value & SALT_MASK;
+	}
+
 	inline void SetSalt(const hash_t &salt) {
 		// Shouldn't be occupied when we set this
 		D_ASSERT(!IsOccupied());

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

@@ -16,7 +16,7 @@ namespace duckdb {
 
 enum class VerifyExistenceType : uint8_t { APPEND = 0, APPEND_FK = 1, DELETE_FK = 2 };
 enum class ARTConflictType : uint8_t { NO_CONFLICT = 0, CONSTRAINT = 1, TRANSACTION = 2 };
-enum class ARTHandlingResult : uint8_t { CONTINUE = 0, SKIP = 1, YIELD = 2 };
+enum class ARTHandlingResult : uint8_t { CONTINUE = 0, SKIP = 1, YIELD = 2, NONE = 3 };
 
 class ConflictManager;
 class ARTKey;
@@ -72,7 +72,7 @@ public:
 	unique_ptr<IndexScanState> TryInitializeScan(const Expression &expr, const Expression &filter_expr);
 	//! Perform a lookup on the ART, fetching up to max_count row IDs.
 	//! If all row IDs were fetched, it return true, else false.
-	bool Scan(IndexScanState &state, idx_t max_count, unsafe_vector<row_t> &row_ids);
+	bool Scan(IndexScanState &state, idx_t max_count, set<row_t> &row_ids);
 
 	//! Appends data to the locked index.
 	ErrorData Append(IndexLock &l, DataChunk &chunk, Vector &row_ids) override;
@@ -92,8 +92,8 @@ public:
 	//! Drop the ART.
 	void CommitDrop(IndexLock &index_lock) override;
 
-	//! Construct an ART from a vector of sorted keys and their row IDs.
-	bool Construct(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count);
+	//! Build an ART from a vector of sorted keys and their row IDs.
+	ARTConflictType Build(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count);
 
 	//! Merge another ART into this ART. Both must be locked.
 	//! FIXME: Return ARTConflictType instead of a boolean.
@@ -102,8 +102,11 @@ public:
 	//! Vacuums the ART storage.
 	void Vacuum(IndexLock &state) override;
 
-	//! Returns ART storage serialization information.
-	IndexStorageInfo GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) override;
+	//! Serializes ART memory to disk and returns the ART storage information.
+	IndexStorageInfo SerializeToDisk(QueryContext context, const case_insensitive_map_t<Value> &options) override;
+	//! Serializes ART memory to the WAL and returns the ART storage information.
+	IndexStorageInfo SerializeToWAL(const case_insensitive_map_t<Value> &options) override;
+
 	//! Returns the in-memory usage of the ART.
 	idx_t GetInMemorySize(IndexLock &index_lock) override;
 
@@ -121,11 +124,11 @@ public:
 	void VerifyBuffers(IndexLock &l) override;
 
 private:
-	bool SearchEqual(ARTKey &key, idx_t max_count, unsafe_vector<row_t> &row_ids);
-	bool SearchGreater(ARTKey &key, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids);
-	bool SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids);
+	bool SearchEqual(ARTKey &key, idx_t max_count, set<row_t> &row_ids);
+	bool SearchGreater(ARTKey &key, bool equal, idx_t max_count, set<row_t> &row_ids);
+	bool SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, set<row_t> &row_ids);
 	bool SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal, bool right_equal, idx_t max_count,
-	                      unsafe_vector<row_t> &row_ids);
+	                      set<row_t> &row_ids);
 
 	string GenerateErrorKeyName(DataChunk &input, idx_t row);
 	string GenerateConstraintErrorMessage(VerifyExistenceType verify_type, const string &key_name);
@@ -135,11 +138,6 @@ private:
 	string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
 	                                     DataChunk &input) override;
 
-	void Erase(Node &node, reference<const ARTKey> key, idx_t depth, reference<const ARTKey> row_id, GateStatus status);
-
-	bool ConstructInternal(const unsafe_vector<ARTKey> &keys, const unsafe_vector<ARTKey> &row_ids, Node &node,
-	                       ARTKeySection &section);
-
 	void InitializeMergeUpperBounds(unsafe_vector<idx_t> &upper_bounds);
 	void InitializeMerge(Node &node, unsafe_vector<idx_t> &upper_bounds);
 
@@ -148,8 +146,9 @@ private:
 
 	void InitAllocators(const IndexStorageInfo &info);
 	void TransformToDeprecated();
+	IndexStorageInfo PrepareSerialize(const case_insensitive_map_t<Value> &options, const bool v1_0_0_storage);
 	void Deserialize(const BlockPointer &pointer);
-	void WritePartialBlocks(const bool v1_0_0_storage);
+	void WritePartialBlocks(QueryContext context, const bool v1_0_0_storage);
 	void SetPrefixCount(const IndexStorageInfo &info);
 
 	string VerifyAndToStringInternal(const bool only_verify);

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/art_builder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/common/stack.hpp"
+
+namespace duckdb {
+
+class ARTBuilder {
+public:
+	ARTBuilder() = delete;
+	ARTBuilder(ArenaAllocator &arena, ART &art, const unsafe_vector<ARTKey> &keys, const unsafe_vector<ARTKey> &row_ids)
+	    : arena(arena), art(art), keys(keys), row_ids(row_ids) {
+	}
+
+public:
+	//! Initialize the ART builder by passing a reference to the root node.
+	void Init(Node &node, const idx_t end) {
+		s.emplace(node, 0, end, 0);
+	}
+	//! Build the ART starting at the first entry in the stack.
+	ARTConflictType Build();
+
+private:
+	struct NodeEntry {
+		NodeEntry() = delete;
+		NodeEntry(Node &node, const idx_t start, const idx_t end, const idx_t depth)
+		    : node(node), start(start), end(end), depth(depth) {};
+
+		Node &node;
+		idx_t start;
+		idx_t end;
+		idx_t depth;
+	};
+
+	//! The arena holds any temporary memory allocated during the Build phase.
+	ArenaAllocator &arena;
+	//! The ART holding the node memory.
+	ART &art;
+	//! The keys to build the ART from.
+	const unsafe_vector<ARTKey> &keys;
+	//! The row IDs matching the keys.
+	const unsafe_vector<ARTKey> &row_ids;
+	//! The stack. While merging, NodeEntry elements are pushed onto of the stack.
+	stack<NodeEntry> s;
+};
+
+} // namespace duckdb

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

@@ -91,17 +91,4 @@ ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const char *value);
 template <>
 void ARTKey::CreateARTKey(ArenaAllocator &allocator, ARTKey &key, string_t value);
 
-class ARTKeySection {
-public:
-	ARTKeySection(idx_t start, idx_t end, idx_t depth, data_t byte);
-	ARTKeySection(idx_t start, idx_t end, const unsafe_vector<ARTKey> &keys, const ARTKeySection &section);
-
-	idx_t start;
-	idx_t end;
-	idx_t depth;
-	data_t key_byte;
-
-public:
-	void GetChildSections(unsafe_vector<ARTKeySection> &sections, const unsafe_vector<ARTKey> &keys);
-};
 } // namespace duckdb

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

@@ -5,6 +5,7 @@
 //
 //
 //===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/stack.hpp"

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

@@ -5,6 +5,7 @@
 //
 //
 //===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/execution/index/art/art_key.hpp"
@@ -108,8 +109,9 @@ public:
 
 			const auto type = active_node.GetType();
 			switch (type) {
-			case NType::LEAF_INLINED:
+			case NType::LEAF_INLINED: {
 				return InsertIntoInlined(arena, art, active_node, key, row_id, depth, status, delete_art, append_mode);
+			}
 			case NType::LEAF: {
 				Leaf::TransformToNested(art, active_node);
 				continue;
@@ -159,6 +161,116 @@ public:
 		throw InternalException("node without metadata in ARTOperator::Insert");
 	}
 
+	//! Delete a key and its row ID.
+	//! Assumes that deletion starts at the root of the tree.
+	static void Delete(ART &art, Node &node, const ARTKey &key, const ARTKey &row_id) {
+		// If we need to compress a Node4 into a one-way node,
+		// then we need the previous prefix before the Node4.
+		Node empty;
+		reference<Node> greatgrandparent(empty);
+		reference<Node> grandparent(empty);
+		reference<Node> parent(node);
+		reference<Node> current(node);
+		reference<const ARTKey> current_key(key);
+
+		idx_t grandparent_depth = 0;
+		idx_t parent_depth = 0;
+		idx_t depth = 0;
+		auto status = GateStatus::GATE_NOT_SET;
+		auto passed_node = false;
+
+		while (current.get().HasMetadata()) {
+			// Enter gate.
+			if (status == GateStatus::GATE_NOT_SET && current.get().GetGateStatus() == GateStatus::GATE_SET) {
+				status = GateStatus::GATE_SET;
+				current_key = row_id;
+				depth = 0;
+				continue;
+			}
+
+			const auto type = current.get().GetType();
+			switch (type) {
+			case NType::LEAF_INLINED: {
+				if (current.get().GetRowId() != row_id.GetRowId()) {
+					return;
+				}
+				if (!passed_node && parent.get().GetType() == NType::PREFIX) {
+					// The tree contains exactly one element with a prefix.
+					Node::FreeTree(art, parent);
+					return;
+				}
+				if (parent.get().GetType() == NType::PREFIX) {
+					// We might have to compress:
+					// PREFIX (greatgrandparent) - Node4 (grandparent) - PREFIX - INLINED_LEAF.
+					Node::DeleteChild(art, grandparent, greatgrandparent, current_key.get()[grandparent_depth], status,
+					                  row_id);
+					return;
+				}
+				Node::DeleteChild(art, parent, grandparent, current_key.get()[parent_depth], status, row_id);
+				return;
+			}
+			case NType::LEAF: {
+				D_ASSERT(status == GateStatus::GATE_NOT_SET);
+				Leaf::TransformToNested(art, current);
+				break;
+			}
+			case NType::PREFIX: {
+				greatgrandparent = grandparent;
+				grandparent = parent;
+				parent = current;
+				grandparent_depth = parent_depth;
+				parent_depth = depth;
+
+				// Traverse a prefix chain until the next non-prefix node or gate.
+				while (current.get().GetType() == NType::PREFIX) {
+					Prefix prefix(art, current, true);
+					for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
+						if (prefix.data[i] != current_key.get()[depth]) {
+							return;
+						}
+						depth++;
+					}
+					current = *prefix.ptr;
+					if (current.get().GetGateStatus() == GateStatus::GATE_SET) {
+						break;
+					}
+				}
+				break;
+			}
+			case NType::NODE_4:
+			case NType::NODE_16:
+			case NType::NODE_48:
+			case NType::NODE_256: {
+				passed_node = true;
+				greatgrandparent = grandparent;
+				grandparent = parent;
+				parent = current;
+				grandparent_depth = parent_depth;
+				parent_depth = depth;
+
+				auto child = current.get().GetChildMutable(art, current_key.get()[depth]);
+				if (!child) {
+					// No child at the byte: nothing to erase.
+					return;
+				}
+
+				current = *child;
+				depth++;
+				break;
+			}
+			case NType::NODE_7_LEAF:
+			case NType::NODE_15_LEAF:
+			case NType::NODE_256_LEAF: {
+				const auto byte = current_key.get()[depth];
+				if (current.get().HasByte(art, byte)) {
+					Node::DeleteChild(art, current, parent, byte, status, row_id);
+				}
+				return;
+			}
+			}
+		}
+	}
+
 private:
 	static ARTConflictType InsertIntoInlined(ArenaAllocator &arena, ART &art, Node &node, const ARTKey &key,
 	                                         const ARTKey &row_id, const idx_t depth, const GateStatus status,

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

@@ -5,6 +5,7 @@
 //
 //
 //===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/stack.hpp"
@@ -71,7 +72,7 @@ public:
 				break;
 			}
 			default:
-				throw InternalException("invalid node type for ART ARTScanner: %s", EnumUtil::ToString(type));
+				throw InternalException("invalid node type for ART ARTScanner: %d", type);
 			}
 		}
 	}
@@ -80,9 +81,11 @@ private:
 	template <class FUNC>
 	void Emplace(FUNC &&handler, NODE &node) {
 		if (HANDLING == ARTScanHandling::EMPLACE) {
-			if (handler(node) == ARTHandlingResult::SKIP) {
+			auto result = handler(node);
+			if (result == ARTHandlingResult::SKIP) {
 				return;
 			}
+			D_ASSERT(result == ARTHandlingResult::CONTINUE);
 		}
 		s.emplace(node);
 	}

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

@@ -41,7 +41,7 @@ public:
 	}
 
 	//! Returns true, if the byte exists, else false.
-	bool HasByte(uint8_t &byte) const {
+	bool HasByte(const uint8_t byte) const {
 		for (uint8_t i = 0; i < count; i++) {
 			if (key[i] == byte) {
 				return true;
@@ -109,6 +109,7 @@ public:
 
 private:
 	static void GrowNode7Leaf(ART &art, Node &node15_leaf, Node &node7_leaf);
+	//! We shrink at <= Node48::SHRINK_THRESHOLD.
 	static void ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_leaf);
 };
 

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

@@ -31,22 +31,23 @@ private:
 	Node children[CAPACITY];
 
 public:
-	//! Get a new BaseNode and initialize it.
-	static BaseNode &New(ART &art, Node &node) {
+	//! Get a new BaseNode handle and initialize the base node.
+	static NodeHandle<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;
-	}
+		NodeHandle<BaseNode> handle(art, node);
+		auto &n = handle.Get();
 
-	//! 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]);
+		// Reset the node (count).
+		n.count = 0;
+		// Zero-initialize the node.
+		for (uint8_t i = 0; i < CAPACITY; i++) {
+			n.key[i] = 0;
+			n.children[i].Clear();
 		}
+
+		return handle;
 	}
 
 	//! Replace the child at byte.
@@ -66,10 +67,12 @@ public:
 	}
 
 	//! Get the child at byte.
-	static unsafe_optional_ptr<Node> GetChild(BaseNode &n, const uint8_t byte) {
+	static unsafe_optional_ptr<Node> GetChild(BaseNode &n, const uint8_t byte, const bool unsafe = false) {
 		for (uint8_t i = 0; i < n.count; i++) {
 			if (n.key[i] == byte) {
-				D_ASSERT(n.children[i].HasMetadata());
+				if (!unsafe && !n.children[i].HasMetadata()) {
+					throw InternalException("empty child i = %d for byte %d in BaseNode::GetChild", i, byte);
+				}
 				return &n.children[i];
 			}
 		}
@@ -101,7 +104,6 @@ public:
 			children_ptr[i] = children[i];
 		}
 
-		count = 0;
 		return NodeChildren(bytes, children_ptr);
 	}
 
@@ -115,7 +117,7 @@ public:
 
 private:
 	static void InsertChildInternal(BaseNode &n, const uint8_t byte, const Node child);
-	static BaseNode &DeleteChildInternal(ART &art, Node &node, const uint8_t byte);
+	static NodeHandle<BaseNode> DeleteChildInternal(ART &art, Node &node, const uint8_t byte);
 };
 
 //! Node4 holds up to four children sorted by their key byte.
@@ -152,6 +154,7 @@ public:
 
 private:
 	static void GrowNode4(ART &art, Node &node16, Node &node4);
+	//! We shrink at < Node48::SHRINK_THRESHOLD.
 	static void ShrinkNode48(ART &art, Node &node16, Node &node48);
 };
 

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

@@ -65,7 +65,7 @@ public:
 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, unsafe_vector<row_t> &row_ids, const bool equal);
+	bool Scan(const ARTKey &upper_bound, const idx_t max_count, set<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

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

@@ -54,7 +54,7 @@ public:
 	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);
+	static bool DeprecatedGetRowIds(ART &art, const Node &node, set<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.

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

@@ -52,8 +52,10 @@ public:
 public:
 	//! Get a new pointer to a node and initialize it.
 	static void New(ART &art, Node &node, const NType type);
+	//! Free the node.
+	static void FreeNode(ART &art, Node &node);
 	//! Free the node and its children.
-	static void Free(ART &art, Node &node);
+	static void FreeTree(ART &art, Node &node);
 
 	//! Get a reference to the allocator.
 	static FixedSizeAllocator &GetAllocator(const ART &art, const NType type);
@@ -84,11 +86,11 @@ public:
 	//! Get the immutable child at byte.
 	const unsafe_optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
 	//! Get the child at byte.
-	unsafe_optional_ptr<Node> GetChildMutable(ART &art, const uint8_t byte) const;
+	unsafe_optional_ptr<Node> GetChildMutable(ART &art, const uint8_t byte, const bool unsafe = false) const;
 	//! Get the first immutable child greater than or equal to the byte.
 	const unsafe_optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte) const;
 	//! Returns true, if the byte exists, else false.
-	bool HasByte(ART &art, uint8_t &byte) const;
+	bool HasByte(ART &art, const uint8_t byte) const;
 	//! Get the first byte greater than or equal to the byte.
 	bool GetNextByte(ART &art, uint8_t &byte) const;
 
@@ -169,4 +171,29 @@ struct NodeChildren {
 	array_ptr<Node> children;
 };
 
+template <class T>
+class NodeHandle {
+public:
+	NodeHandle(ART &art, const Node node)
+	    : handle(Node::GetAllocator(art, node.GetType()).GetHandle(node)), n(handle.GetRef<T>()) {
+		handle.MarkModified();
+	}
+
+	NodeHandle(const NodeHandle &) = delete;
+	NodeHandle &operator=(const NodeHandle &) = delete;
+
+	NodeHandle(NodeHandle &&other) noexcept : handle(std::move(other.handle)), n(handle.GetRef<T>()) {
+	}
+	NodeHandle &operator=(NodeHandle &&other) noexcept = delete;
+
+public:
+	T &Get() {
+		return n;
+	}
+
+private:
+	SegmentHandle handle;
+	T &n;
+};
+
 } // namespace duckdb