duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -4,11 +4,7 @@
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/execution/index/art/art_builder.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/art_merger.hpp"
-#include "duckdb/execution/index/art/art_operator.hpp"
-#include "duckdb/execution/index/art/art_scanner.hpp"
 #include "duckdb/execution/index/art/base_leaf.hpp"
 #include "duckdb/execution/index/art/base_node.hpp"
 #include "duckdb/execution/index/art/iterator.hpp"
@@ -25,6 +21,9 @@
 #include "duckdb/storage/metadata/metadata_reader.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
+#include "duckdb/execution/index/art/art_scanner.hpp"
+#include "duckdb/execution/index/art/art_merger.hpp"
+#include "duckdb/execution/index/art/art_operator.hpp"
 
 namespace duckdb {
 
@@ -36,7 +35,7 @@ struct ARTIndexScanState : public IndexScanState {
 	ExpressionType expressions[2];
 	bool checked = false;
 	//! All scanned row IDs.
-	set<row_t> row_ids;
+	unsafe_vector<row_t> row_ids;
 };
 
 //===--------------------------------------------------------------------===//
@@ -208,8 +207,6 @@ unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const
 		high_comparison_type =
 		    between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
 	}
-	// FIXME: add another if...else... to match rewritten BETWEEN,
-	// i.e., WHERE i BETWEEN 50 AND 1502 is rewritten to CONJUNCTION_AND.
 
 	// We cannot use an index scan.
 	if (equal_value.IsNull() && low_value.IsNull() && high_value.IsNull()) {
@@ -425,29 +422,87 @@ void ART::GenerateKeyVectors(ArenaAllocator &allocator, DataChunk &input, Vector
 }
 
 //===--------------------------------------------------------------------===//
-// Build from sorted data.
+// Construct from sorted data.
 //===--------------------------------------------------------------------===//
 
-ARTConflictType ART::Build(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count) {
-	ArenaAllocator arena(BufferAllocator::Get(db));
-	ARTBuilder builder(arena, *this, keys, row_ids);
-	builder.Init(tree, row_count - 1);
+bool ART::ConstructInternal(const unsafe_vector<ARTKey> &keys, const unsafe_vector<ARTKey> &row_ids, Node &node,
+                            ARTKeySection &section) {
+	D_ASSERT(section.start < keys.size());
+	D_ASSERT(section.end < keys.size());
+	D_ASSERT(section.start <= section.end);
 
-	auto result = builder.Build();
-	if (result != ARTConflictType::NO_CONFLICT) {
-		return result;
+	auto &start = keys[section.start];
+	auto &end = keys[section.end];
+	D_ASSERT(start.len != 0);
+
+	// Increment the depth until we reach a leaf or find a mismatching byte.
+	auto prefix_depth = section.depth;
+	while (start.len != section.depth && start.ByteMatches(end, section.depth)) {
+		section.depth++;
+	}
+
+	if (start.len == section.depth) {
+		// We reached a leaf. All the bytes of start_key and end_key match.
+		auto row_id_count = section.end - section.start + 1;
+		if (IsUnique() && row_id_count != 1) {
+			return false;
+		}
+
+		reference<Node> ref(node);
+		auto count = UnsafeNumericCast<uint8_t>(start.len - prefix_depth);
+		Prefix::New(*this, ref, start, prefix_depth, count);
+		if (row_id_count == 1) {
+			Leaf::New(ref, row_ids[section.start].GetRowId());
+		} else {
+			// Loop and insert the row IDs.
+			// We cannot use Construct in the leaf because row IDs are not sorted.
+			ArenaAllocator arena(BufferAllocator::Get(db));
+			for (idx_t i = section.start; i < section.start + row_id_count; i++) {
+				ARTOperator::Insert(arena, *this, ref, row_ids[i], 0, row_ids[i], GateStatus::GATE_SET, nullptr,
+				                    IndexAppendMode::DEFAULT);
+			}
+			ref.get().SetGateStatus(GateStatus::GATE_SET);
+		}
+		return true;
+	}
+
+	// Create a new node and recurse.
+	unsafe_vector<ARTKeySection> children;
+	section.GetChildSections(children, keys);
+
+	// Create the prefix.
+	reference<Node> ref(node);
+	auto prefix_length = section.depth - prefix_depth;
+	Prefix::New(*this, ref, start, prefix_depth, prefix_length);
+
+	// Create the node.
+	Node::New(*this, ref, Node::GetNodeType(children.size()));
+	for (auto &child : children) {
+		Node new_child;
+		auto success = ConstructInternal(keys, row_ids, new_child, child);
+		Node::InsertChild(*this, ref, child.key_byte, new_child);
+		if (!success) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool ART::Construct(unsafe_vector<ARTKey> &keys, unsafe_vector<ARTKey> &row_ids, const idx_t row_count) {
+	ARTKeySection section(0, row_count - 1, 0, 0);
+	if (!ConstructInternal(keys, row_ids, tree, section)) {
+		return false;
 	}
 
 #ifdef DEBUG
-	set<row_t> row_ids_debug;
+	unsafe_vector<row_t> row_ids_debug;
 	Iterator it(*this);
 	it.FindMinimum(tree);
 	ARTKey empty_key = ARTKey();
 	it.Scan(empty_key, NumericLimits<row_t>().Maximum(), row_ids_debug, false);
 	D_ASSERT(row_count == row_ids_debug.size());
 #endif
-
-	return ARTConflictType::NO_CONFLICT;
+	return true;
 }
 
 //===--------------------------------------------------------------------===//
@@ -497,8 +552,7 @@ ErrorData ART::Insert(IndexLock &l, DataChunk &chunk, Vector &row_ids, IndexAppe
 			if (keys[i].Empty()) {
 				continue;
 			}
-			D_ASSERT(tree.GetGateStatus() == GateStatus::GATE_NOT_SET);
-			ARTOperator::Delete(*this, tree, keys[i], row_id_keys[i]);
+			Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
 		}
 	}
 
@@ -551,7 +605,7 @@ ErrorData ART::Append(IndexLock &l, DataChunk &chunk, Vector &row_ids, IndexAppe
 
 void ART::VerifyAppend(DataChunk &chunk, IndexAppendInfo &info, optional_ptr<ConflictManager> manager) {
 	if (manager) {
-		D_ASSERT(manager->GetVerifyExistenceType() == VerifyExistenceType::APPEND);
+		D_ASSERT(manager->LookupType() == VerifyExistenceType::APPEND);
 		return VerifyConstraint(chunk, info, *manager);
 	}
 	ConflictManager local_manager(VerifyExistenceType::APPEND, chunk.size());
@@ -587,8 +641,7 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-		D_ASSERT(tree.GetGateStatus() == GateStatus::GATE_NOT_SET);
-		ARTOperator::Delete(*this, tree, keys[i], row_id_keys[i]);
+		Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
 	}
 
 	if (!tree.HasMetadata()) {
@@ -609,11 +662,106 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 #endif
 }
 
+void ART::Erase(Node &node, reference<const ARTKey> key, idx_t depth, reference<const ARTKey> row_id,
+                GateStatus status) {
+	if (!node.HasMetadata()) {
+		return;
+	}
+
+	// Traverse the prefix.
+	reference<Node> next(node);
+	if (next.get().GetType() == NType::PREFIX) {
+		auto pos = Prefix::TraverseMutable(*this, next, key, depth);
+		if (pos.IsValid()) {
+			// Prefixes don't match: nothing to erase.
+			return;
+		}
+	}
+
+	//	Delete the row ID from the leaf.
+	//	This is the root node, which can be a leaf with possible prefix nodes.
+	if (next.get().GetType() == NType::LEAF_INLINED) {
+		if (next.get().GetRowId() == row_id.get().GetRowId()) {
+			Node::Free(*this, node);
+		}
+		return;
+	}
+
+	// Transform a deprecated leaf.
+	if (next.get().GetType() == NType::LEAF) {
+		D_ASSERT(status == GateStatus::GATE_NOT_SET);
+		Leaf::TransformToNested(*this, next);
+	}
+
+	// Enter a nested leaf.
+	if (status == GateStatus::GATE_NOT_SET && next.get().GetGateStatus() == GateStatus::GATE_SET) {
+		return Erase(next, row_id, 0, row_id, GateStatus::GATE_SET);
+	}
+
+	D_ASSERT(depth < key.get().len);
+	if (next.get().IsLeafNode()) {
+		auto byte = key.get()[depth];
+		if (next.get().HasByte(*this, byte)) {
+			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
+		}
+		return;
+	}
+
+	auto child = next.get().GetChildMutable(*this, key.get()[depth]);
+	if (!child) {
+		// No child at the byte: nothing to erase.
+		return;
+	}
+
+	// Transform a deprecated leaf.
+	if (child->GetType() == NType::LEAF) {
+		D_ASSERT(status == GateStatus::GATE_NOT_SET);
+		Leaf::TransformToNested(*this, *child);
+	}
+
+	// Enter a nested leaf.
+	if (status == GateStatus::GATE_NOT_SET && child->GetGateStatus() == GateStatus::GATE_SET) {
+		Erase(*child, row_id, 0, row_id, GateStatus::GATE_SET);
+		if (!child->HasMetadata()) {
+			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
+		} else {
+			next.get().ReplaceChild(*this, key.get()[depth], *child);
+		}
+		return;
+	}
+
+	auto temp_depth = depth + 1;
+	reference<Node> ref(*child);
+
+	if (ref.get().GetType() == NType::PREFIX) {
+		auto pos = Prefix::TraverseMutable(*this, ref, key, temp_depth);
+		if (pos.IsValid()) {
+			// Prefixes don't match: nothing to erase.
+			return;
+		}
+	}
+
+	if (ref.get().GetType() == NType::LEAF_INLINED) {
+		if (ref.get().GetRowId() == row_id.get().GetRowId()) {
+			Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
+		}
+		return;
+	}
+
+	// Recurse.
+	Erase(*child, key, depth + 1, row_id, status);
+	if (!child->HasMetadata()) {
+		Node::DeleteChild(*this, next, node, key.get()[depth], status, key.get());
+	} else {
+		next.get().ReplaceChild(*this, key.get()[depth], *child);
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Point and range lookups
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchEqual(ARTKey &key, idx_t max_count, set<row_t> &row_ids) {
+bool ART::SearchEqual(ARTKey &key, idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	auto leaf = ARTOperator::Lookup(*this, tree, key, 0);
 	if (!leaf) {
 		return true;
@@ -625,7 +773,7 @@ bool ART::SearchEqual(ARTKey &key, idx_t max_count, set<row_t> &row_ids) {
 	return it.Scan(empty_key, max_count, row_ids, false);
 }
 
-bool ART::SearchGreater(ARTKey &key, bool equal, idx_t max_count, set<row_t> &row_ids) {
+bool ART::SearchGreater(ARTKey &key, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	if (!tree.HasMetadata()) {
 		return true;
 	}
@@ -643,7 +791,7 @@ bool ART::SearchGreater(ARTKey &key, bool equal, idx_t max_count, set<row_t> &ro
 	return it.Scan(ARTKey(), max_count, row_ids, false);
 }
 
-bool ART::SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, set<row_t> &row_ids) {
+bool ART::SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	if (!tree.HasMetadata()) {
 		return true;
 	}
@@ -662,7 +810,7 @@ bool ART::SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, set<row_t
 }
 
 bool ART::SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal, bool right_equal, idx_t max_count,
-                           set<row_t> &row_ids) {
+                           unsafe_vector<row_t> &row_ids) {
 	// Find the first node that satisfies the left predicate.
 	Iterator it(*this);
 
@@ -675,7 +823,7 @@ bool ART::SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_e
 	return it.Scan(upper_bound, max_count, row_ids, right_equal);
 }
 
-bool ART::Scan(IndexScanState &state, const idx_t max_count, set<row_t> &row_ids) {
+bool ART::Scan(IndexScanState &state, const idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	auto &scan_state = state.Cast<ARTIndexScanState>();
 	D_ASSERT(scan_state.values[0].type().InternalType() == types[0]);
 	ArenaAllocator arena_allocator(Allocator::Get(db));
@@ -789,6 +937,9 @@ void ART::VerifyLeaf(const Node &leaf, const ARTKey &key, optional_ptr<ART> dele
 		auto this_row_id = leaf.GetRowId();
 
 		if (deleted_row_id == this_row_id) {
+			if (manager.AddMiss(i)) {
+				conflict_idx = i;
+			}
 			return;
 		}
 
@@ -814,27 +965,30 @@ void ART::VerifyLeaf(const Node &leaf, const ARTKey &key, optional_ptr<ART> dele
 	Iterator it(*this);
 	it.FindMinimum(leaf);
 	ARTKey empty_key = ARTKey();
-	set<row_t> row_ids;
+	unsafe_vector<row_t> row_ids;
 	auto success = it.Scan(empty_key, 2, row_ids, false);
 	if (!success || row_ids.size() != 2) {
 		throw InternalException("VerifyLeaf expects exactly two row IDs to be scanned");
 	}
 
-	if (deleted_leaf) {
-		auto deleted_row_id = deleted_leaf->GetRowId();
-		for (const auto row_id : row_ids) {
-			if (deleted_row_id == row_id) {
-				return;
-			}
+	if (!deleted_leaf) {
+		if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[1])) {
+			conflict_idx = i;
+		}
+		return;
+	}
+
+	auto deleted_row_id = deleted_leaf->GetRowId();
+	if (deleted_row_id == row_ids[0] || deleted_row_id == row_ids[1]) {
+		if (manager.AddMiss(i)) {
+			conflict_idx = i;
 		}
+		return;
 	}
 
-	auto row_id_it = row_ids.begin();
-	if (manager.AddHit(i, *row_id_it)) {
+	if (manager.AddHit(i, row_ids[0]) || manager.AddHit(i, row_ids[1])) {
 		conflict_idx = i;
 	}
-	row_id_it++;
-	manager.AddSecondHit(i, *row_id_it);
 }
 
 void ART::VerifyConstraint(DataChunk &chunk, IndexAppendInfo &info, ConflictManager &manager) {
@@ -865,6 +1019,9 @@ void ART::VerifyConstraint(DataChunk &chunk, IndexAppendInfo &info, ConflictMana
 
 		auto leaf = ARTOperator::Lookup(*this, tree, keys[i], 0);
 		if (!leaf) {
+			if (manager.AddMiss(i)) {
+				conflict_idx = i;
+			}
 			continue;
 		}
 		VerifyLeaf(*leaf, keys[i], delete_art, manager, conflict_idx, i);
@@ -876,7 +1033,7 @@ void ART::VerifyConstraint(DataChunk &chunk, IndexAppendInfo &info, ConflictMana
 	}
 
 	auto key_name = GenerateErrorKeyName(chunk, conflict_idx.GetIndex());
-	auto exception_msg = GenerateConstraintErrorMessage(manager.GetVerifyExistenceType(), key_name);
+	auto exception_msg = GenerateConstraintErrorMessage(manager.LookupType(), key_name);
 	throw ConstraintException(exception_msg);
 }
 
@@ -915,7 +1072,11 @@ void ART::TransformToDeprecated() {
 	}
 }
 
-IndexStorageInfo ART::PrepareSerialize(const case_insensitive_map_t<Value> &options, const bool v1_0_0_storage) {
+IndexStorageInfo ART::GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal) {
+	// If the storage format uses deprecated leaf storage,
+	// then we need to transform all nested leaves before serialization.
+	auto v1_0_0_option = options.find("v1_0_0_storage");
+	bool v1_0_0_storage = v1_0_0_option == options.end() || v1_0_0_option->second != Value(false);
 	if (v1_0_0_storage) {
 		TransformToDeprecated();
 	}
@@ -938,50 +1099,27 @@ IndexStorageInfo ART::PrepareSerialize(const case_insensitive_map_t<Value> &opti
 	}
 #endif
 
-	return info;
-}
-
-IndexStorageInfo ART::SerializeToDisk(QueryContext context, const case_insensitive_map_t<Value> &options) {
-	// If the storage format uses deprecated leaf storage,
-	// then we need to transform all nested leaves before serialization.
-	auto v1_0_0_option = options.find("v1_0_0_storage");
-	bool v1_0_0_storage = v1_0_0_option == options.end() || v1_0_0_option->second != Value(false);
-	auto info = PrepareSerialize(options, v1_0_0_storage);
 	auto allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
-
-	// Store the data on disk as partial blocks and set the block ids.
-	WritePartialBlocks(context, v1_0_0_storage);
-
-	for (idx_t i = 0; i < allocator_count; i++) {
-		info.allocator_infos.push_back((*allocators)[i]->GetInfo());
-	}
-
-	return info;
-}
-
-IndexStorageInfo ART::SerializeToWAL(const case_insensitive_map_t<Value> &options) {
-	// If the storage format uses deprecated leaf storage,
-	// then we need to transform all nested leaves before serialization.
-	auto v1_0_0_option = options.find("v1_0_0_storage");
-	bool v1_0_0_storage = v1_0_0_option == options.end() || v1_0_0_option->second != Value(false);
-	auto info = PrepareSerialize(options, v1_0_0_storage);
-	auto allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
-
-	// Set the correct allocation sizes and get the map containing all buffers.
-	for (idx_t i = 0; i < allocator_count; i++) {
-		info.buffers.push_back((*allocators)[i]->InitSerializationToWAL());
+	if (!to_wal) {
+		// Store the data on disk as partial blocks and set the block ids.
+		WritePartialBlocks(v1_0_0_storage);
+
+	} else {
+		// Set the correct allocation sizes and get the map containing all buffers.
+		for (idx_t i = 0; i < allocator_count; i++) {
+			info.buffers.push_back((*allocators)[i]->InitSerializationToWAL());
+		}
 	}
 
 	for (idx_t i = 0; i < allocator_count; i++) {
 		info.allocator_infos.push_back((*allocators)[i]->GetInfo());
 	}
-
 	return info;
 }
 
-void ART::WritePartialBlocks(QueryContext context, const bool v1_0_0_storage) {
+void ART::WritePartialBlocks(const bool v1_0_0_storage) {
 	auto &block_manager = table_io_manager.GetIndexBlockManager();
-	PartialBlockManager partial_block_manager(context, block_manager, PartialBlockType::FULL_CHECKPOINT);
+	PartialBlockManager partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT);
 
 	idx_t allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
 	for (idx_t i = 0; i < allocator_count; i++) {
@@ -1114,7 +1252,7 @@ void ART::Vacuum(IndexLock &state) {
 			break;
 		}
 		default:
-			throw InternalException("invalid node type for Vacuum: %d", type);
+			throw InternalException("invalid node type for Vacuum: %s", EnumUtil::ToString(type));
 		}
 
 		const auto idx = Node::GetAllocatorIdx(type);
@@ -1153,14 +1291,14 @@ void ART::InitializeMerge(Node &node, unsafe_vector<idx_t> &upper_bounds) {
 	auto handler = [&upper_bounds](Node &node) {
 		const auto type = node.GetType();
 		if (node.GetType() == NType::LEAF_INLINED) {
-			return ARTHandlingResult::NONE;
+			return ARTHandlingResult::CONTINUE;
 		}
 		if (type == NType::LEAF) {
 			throw InternalException("deprecated ART storage in InitializeMerge");
 		}
 		const auto idx = Node::GetAllocatorIdx(type);
 		node.IncreaseBufferId(upper_bounds[idx]);
-		return ARTHandlingResult::NONE;
+		return ARTHandlingResult::CONTINUE;
 	};
 
 	ARTScanner<ARTScanHandling::POP, Node> scanner(*this, handler, node);

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

@@ -163,4 +163,27 @@ idx_t ARTKey::GetMismatchPos(const ARTKey &other, const idx_t start) const {
 	return DConstants::INVALID_INDEX;
 }
 
+//===--------------------------------------------------------------------===//
+// ARTKeySection
+//===--------------------------------------------------------------------===//
+
+ARTKeySection::ARTKeySection(idx_t start, idx_t end, idx_t depth, data_t byte)
+    : start(start), end(end), depth(depth), key_byte(byte) {
+}
+
+ARTKeySection::ARTKeySection(idx_t start, idx_t end, const unsafe_vector<ARTKey> &keys, const ARTKeySection &section)
+    : start(start), end(end), depth(section.depth + 1), key_byte(keys[end].data[section.depth]) {
+}
+
+void ARTKeySection::GetChildSections(unsafe_vector<ARTKeySection> &sections, const unsafe_vector<ARTKey> &keys) {
+	auto child_idx = start;
+	for (idx_t i = start + 1; i <= end; i++) {
+		if (keys[i - 1].data[depth] != keys[i].data[depth]) {
+			sections.emplace_back(child_idx, i - 1, keys, *this);
+			child_idx = i;
+		}
+	}
+	sections.emplace_back(child_idx, end, keys, *this);
+}
+
 } // namespace duckdb

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

@@ -144,7 +144,7 @@ void ARTMerger::MergeLeaves(NodeEntry &entry) {
 	for (idx_t i = 0; i < bytes.size(); i++) {
 		Node::InsertChild(art, entry.left, bytes[i]);
 	}
-	Node::FreeNode(art, entry.right);
+	Node::Free(art, entry.right);
 }
 
 NodeChildren ARTMerger::ExtractChildren(Node &node) {
@@ -177,7 +177,7 @@ void ARTMerger::MergeNodes(NodeEntry &entry) {
 	auto children = ExtractChildren(entry.right);
 	// As long as the arena is valid,
 	// the copied-out nodes (and their references) are valid.
-	Node::FreeNode(art, entry.right);
+	Node::Free(art, entry.right);
 
 	// First, we iterate and insert children.
 	// This might grow the node, so we need to do it prior to Emplace.
@@ -300,7 +300,8 @@ void ARTMerger::MergePrefixes(NodeEntry &entry) {
 		// Free the right prefix, but keep the reference to its child alive.
 		// Then, iterate on the left and right (reduced) child.
 		auto r_child = *r_prefix.ptr;
-		Node::FreeNode(art, entry.right);
+		r_prefix.ptr->Clear();
+		Node::Free(art, entry.right);
 		entry.right = r_child;
 
 		auto depth = entry.depth + l_prefix.data[count];

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

@@ -76,16 +76,15 @@ void Node7Leaf::DeleteByte(ART &art, Node &node, Node &prefix, const uint8_t byt
 		auto remainder = UnsafeNumericCast<idx_t>(row_id.GetRowId()) & AND_LAST_BYTE;
 		remainder |= UnsafeNumericCast<idx_t>(n7.key[0]);
 
-		// Free the prefix (nodes) and inline the remainder.
+		n7.count--;
+		Node::Free(art, node);
+
 		if (prefix.GetType() == NType::PREFIX) {
-			Node::FreeTree(art, prefix);
+			Node::Free(art, prefix);
 			Leaf::New(prefix, UnsafeNumericCast<row_t>(remainder));
-			return;
+		} else {
+			Leaf::New(node, UnsafeNumericCast<row_t>(remainder));
 		}
-
-		// Free the Node7Leaf and inline the remainder.
-		Node::FreeNode(art, node);
-		Leaf::New(node, UnsafeNumericCast<row_t>(remainder));
 	}
 }
 
@@ -99,7 +98,8 @@ void Node7Leaf::ShrinkNode15Leaf(ART &art, Node &node7_leaf, Node &node15_leaf)
 		n7.key[i] = n15.key[i];
 	}
 
-	Node::FreeNode(art, node15_leaf);
+	n15.count = 0;
+	Node::Free(art, node15_leaf);
 }
 
 //===--------------------------------------------------------------------===//
@@ -139,7 +139,8 @@ void Node15Leaf::GrowNode7Leaf(ART &art, Node &node15_leaf, Node &node7_leaf) {
 		n15.key[i] = n7.key[i];
 	}
 
-	Node::FreeNode(art, node7_leaf);
+	n7.count = 0;
+	Node::Free(art, node7_leaf);
 }
 
 void Node15Leaf::ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_leaf) {
@@ -155,7 +156,7 @@ void Node15Leaf::ShrinkNode256Leaf(ART &art, Node &node15_leaf, Node &node256_le
 		}
 	}
 
-	Node::FreeNode(art, node256_leaf);
+	Node::Free(art, node256_leaf);
 }
 
 } // namespace duckdb