duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

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

@@ -18,7 +18,6 @@
 #include "duckdb/storage/table/scan_state.hpp"
 
 #include <algorithm>
-#include <cstring>
 
 namespace duckdb {
 
@@ -125,7 +124,7 @@ static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_
 	input.ToUnifiedFormat(count, idata);
 
 	D_ASSERT(keys.size() >= count);
-	auto input_data = (T *)idata.data;
+	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
 		if (idata.validity.RowIsValid(idx)) {
@@ -142,7 +141,7 @@ static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t coun
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
-	auto input_data = (T *)idata.data;
+	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
 
@@ -347,7 +346,31 @@ bool ART::ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_ide
 
 	auto key_section = KeySection(0, count - 1, 0, 0);
 	auto has_constraint = IsUnique();
-	return Construct(*this, keys, row_ids, *this->tree, key_section, has_constraint);
+	if (!Construct(*this, keys, row_ids, *this->tree, key_section, has_constraint)) {
+		return false;
+	}
+
+#ifdef DEBUG
+	D_ASSERT(!VerifyAndToStringInternal(true).empty());
+	for (idx_t i = 0; i < count; i++) {
+		D_ASSERT(!keys[i].Empty());
+		auto leaf_node = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(*this, leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(*this, leaf_segment, row_ids[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
+	return true;
 }
 
 //===--------------------------------------------------------------------===//
@@ -397,6 +420,29 @@ PreservedError ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 		return PreservedError(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"",
 		                                          AppendRowError(input, failed_index)));
 	}
+
+#ifdef DEBUG
+	for (idx_t i = 0; i < input.size(); i++) {
+		if (keys[i].Empty()) {
+			continue;
+		}
+
+		auto leaf_node = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(*this, leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_identifiers[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
 	return PreservedError();
 }
 
@@ -535,16 +581,31 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 			continue;
 		}
 		Erase(*tree, keys[i], 0, row_identifiers[i]);
+	}
+
 #ifdef DEBUG
+	// verify that we removed all row IDs
+	for (idx_t i = 0; i < input.size(); i++) {
+		if (keys[i].Empty()) {
+			continue;
+		}
+
 		auto node = Lookup(*tree, keys[i], 0);
 		if (node.IsSet()) {
 			auto &leaf = Leaf::Get(*this, node);
-			for (idx_t k = 0; k < leaf.count; k++) {
-				D_ASSERT(leaf.GetRowId(*this, k) != row_identifiers[i]);
+
+			if (leaf.IsInlined()) {
+				D_ASSERT(row_identifiers[i] != leaf.row_ids.inlined);
+				continue;
 			}
+
+			D_ASSERT(leaf.row_ids.ptr.IsSet());
+			Node leaf_segment = leaf.row_ids.ptr;
+			auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
+			D_ASSERT(position == (uint32_t)DConstants::INVALID_INDEX);
 		}
-#endif
 	}
+#endif
 }
 
 void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
@@ -715,16 +776,16 @@ Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {
 //          False (Otherwise)
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, idx_t max_count,
+bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
                         vector<row_t> &result_ids) {
 
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
 	// greater than scan: first set the iterator to the node at which we will start our scan by finding the lowest node
 	// that satisfies our requirement
-	if (!it->art) {
-		it->art = this;
-		if (!it->LowerBound(*tree, key, inclusive)) {
+	if (!it.art) {
+		it.art = this;
+		if (!it.LowerBound(*tree, key, inclusive)) {
 			return true;
 		}
 	}
@@ -732,74 +793,72 @@ bool ART::SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, i
 	// after that we continue the scan; we don't need to check the bounds as any value following this value is
 	// automatically bigger and hence satisfies our predicate
 	ARTKey empty_key = ARTKey();
-	return it->Scan(empty_key, max_count, result_ids, false);
+	return it.Scan(empty_key, max_count, result_ids, false);
 }
 
 //===--------------------------------------------------------------------===//
 // Less Than
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchLess(ARTIndexScanState *state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
+bool ART::SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
                      vector<row_t> &result_ids) {
 
 	if (!tree->IsSet()) {
 		return true;
 	}
 
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
-	if (!it->art) {
-		it->art = this;
+	if (!it.art) {
+		it.art = this;
 		// first find the minimum value in the ART: we start scanning from this value
-		it->FindMinimum(*tree);
+		it.FindMinimum(*tree);
 		// early out min value higher than upper bound query
-		if (it->cur_key > upper_bound) {
+		if (it.cur_key > upper_bound) {
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound, max_count, result_ids, inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, inclusive);
 }
 
 //===--------------------------------------------------------------------===//
 // Closed Range Query
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchCloseRange(ARTIndexScanState *state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
+bool ART::SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
                            bool right_inclusive, idx_t max_count, vector<row_t> &result_ids) {
-
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
 	// first find the first node that satisfies the left predicate
-	if (!it->art) {
-		it->art = this;
-		if (!it->LowerBound(*tree, lower_bound, left_inclusive)) {
+	if (!it.art) {
+		it.art = this;
+		if (!it.LowerBound(*tree, lower_bound, left_inclusive)) {
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound, max_count, result_ids, right_inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, right_inclusive);
 }
 
 bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScanState &table_state,
                const idx_t max_count, vector<row_t> &result_ids) {
-
-	auto state = (ARTIndexScanState *)&table_state;
+	auto &state = table_state.Cast<ARTIndexScanState>();
 	vector<row_t> row_ids;
 	bool success;
 
 	// FIXME: the key directly owning the data for a single key might be more efficient
-	D_ASSERT(state->values[0].type().InternalType() == types[0]);
+	D_ASSERT(state.values[0].type().InternalType() == types[0]);
 	ArenaAllocator arena_allocator(Allocator::Get(db));
-	auto key = CreateKey(arena_allocator, types[0], state->values[0]);
+	auto key = CreateKey(arena_allocator, types[0], state.values[0]);
 
-	if (state->values[1].IsNull()) {
+	if (state.values[1].IsNull()) {
 
 		// single predicate
 		lock_guard<mutex> l(lock);
-		switch (state->expressions[0]) {
+		switch (state.expressions[0]) {
 		case ExpressionType::COMPARE_EQUAL:
 			success = SearchEqual(key, max_count, row_ids);
 			break;
@@ -824,11 +883,11 @@ bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScan
 		// two predicates
 		lock_guard<mutex> l(lock);
 
-		D_ASSERT(state->values[1].type().InternalType() == types[0]);
-		auto upper_bound = CreateKey(arena_allocator, types[0], state->values[1]);
+		D_ASSERT(state.values[1].type().InternalType() == types[0]);
+		auto upper_bound = CreateKey(arena_allocator, types[0], state.values[1]);
 
-		bool left_inclusive = state->expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-		bool right_inclusive = state->expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
+		bool left_inclusive = state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
+		bool right_inclusive = state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
 		success = SearchCloseRange(state, key, upper_bound, left_inclusive, right_inclusive, max_count, row_ids);
 	}
 
@@ -1024,6 +1083,10 @@ void ART::Vacuum(IndexLock &state) {
 
 	// finalize the vacuum operation
 	FinalizeVacuum(flags);
+
+	for (auto &allocator : allocators) {
+		allocator->Verify();
+	}
 }
 
 //===--------------------------------------------------------------------===//
@@ -1061,6 +1124,10 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 	if (!tree->Merge(*this, *other_art.tree)) {
 		return false;
 	}
+
+	for (auto &allocator : allocators) {
+		allocator->Verify();
+	}
 	return true;
 }
 
@@ -1068,9 +1135,13 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 // Utility
 //===--------------------------------------------------------------------===//
 
-string ART::ToString() {
+string ART::VerifyAndToString(IndexLock &state, const bool only_verify) {
+	return VerifyAndToStringInternal(only_verify);
+}
+
+string ART::VerifyAndToStringInternal(const bool only_verify) {
 	if (tree->IsSet()) {
-		return tree->ToString(*this);
+		return "ART: " + tree->VerifyAndToString(*this, only_verify);
 	}
 	return "[empty]";
 }

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

@@ -59,7 +59,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 		buffers_with_free_space.insert(buffer_id);
 
 		// set the bitmask
-		ValidityMask mask((validity_t *)buffer);
+		ValidityMask mask(reinterpret_cast<validity_t *>(buffer));
 		mask.SetAllValid(allocations_per_buffer);
 	}
 
@@ -67,7 +67,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 	D_ASSERT(!buffers_with_free_space.empty());
 	auto buffer_id = (uint32_t)*buffers_with_free_space.begin();
 
-	auto bitmask_ptr = (validity_t *)buffers[buffer_id].ptr;
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[buffer_id].ptr);
 	ValidityMask mask(bitmask_ptr);
 	auto offset = GetOffset(mask, buffers[buffer_id].allocation_count);
 
@@ -81,8 +81,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 }
 
 void FixedSizeAllocator::Free(const SwizzleablePointer ptr) {
-
-	auto bitmask_ptr = (validity_t *)buffers[ptr.buffer_id].ptr;
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.buffer_id].ptr);
 	ValidityMask mask(bitmask_ptr);
 	D_ASSERT(!mask.RowIsValid(ptr.offset));
 	mask.SetValid(ptr.offset);
@@ -127,13 +126,20 @@ void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
 
 bool FixedSizeAllocator::InitializeVacuum() {
 
+	if (total_allocations == 0) {
+		Reset();
+		return false;
+	}
+
 	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
 	auto total_free_positions = total_available_allocations - total_allocations;
 
 	// vacuum_count buffers can be freed
-	auto vacuum_count = total_free_positions / allocations_per_buffer / 2;
+	auto vacuum_count = total_free_positions / allocations_per_buffer;
 
 	// calculate the vacuum threshold adaptively
+	D_ASSERT(vacuum_count < buffers.size());
 	idx_t memory_usage = GetMemoryUsage();
 	idx_t excess_memory_usage = vacuum_count * BUFFER_ALLOC_SIZE;
 	auto excess_percentage = (double)excess_memory_usage / (double)memory_usage;
@@ -172,10 +178,22 @@ SwizzleablePointer FixedSizeAllocator::VacuumPointer(const SwizzleablePointer pt
 	// buffer after the vacuum operation
 
 	auto new_ptr = New();
+
+	// new increases the allocation count
+	total_allocations--;
+
 	memcpy(Get(new_ptr), Get(ptr), allocation_size);
 	return new_ptr;
 }
 
+void FixedSizeAllocator::Verify() const {
+#ifdef DEBUG
+	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
+	D_ASSERT(buffers.size() >= buffers_with_free_space.size());
+#endif
+}
+
 uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t allocation_count) {
 
 	auto data = mask.GetData();

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

@@ -60,16 +60,10 @@ void Leaf::Free(ART &art, Node &node) {
 	D_ASSERT(node.IsSet());
 	D_ASSERT(!node.IsSwizzled());
 
+	// free leaf segments
 	auto &leaf = Leaf::Get(art, node);
-
-	// delete all leaf segments
 	if (!leaf.IsInlined()) {
-		auto ptr = leaf.row_ids.ptr;
-		while (ptr.IsSet()) {
-			auto next_ptr = LeafSegment::Get(art, ptr).next;
-			Node::Free(art, ptr);
-			ptr = next_ptr;
-		}
+		Node::Free(art, leaf.row_ids.ptr);
 	}
 }
 
@@ -275,10 +269,10 @@ uint32_t Leaf::FindRowId(const ART &art, Node &ptr, const row_t row_id) const {
 	return (uint32_t)DConstants::INVALID_INDEX;
 }
 
-string Leaf::ToString(const ART &art) const {
+string Leaf::VerifyAndToString(const ART &art, const bool only_verify) const {
 
 	if (IsInlined()) {
-		return "Leaf (" + to_string(count) + "): [" + to_string(row_ids.inlined) + "]";
+		return only_verify ? "" : "Leaf [count: 1, row ID: " + to_string(row_ids.inlined) + "]";
 	}
 
 	auto ptr = row_ids.ptr;
@@ -296,7 +290,10 @@ string Leaf::ToString(const ART &art) const {
 		remaining -= to_string_count;
 		ptr = segment.next;
 	}
-	return "Leaf (" + to_string(this_count) + ", " + to_string(count) + "): [" + str + "] \n";
+
+	D_ASSERT(remaining == 0);
+	D_ASSERT(this_count == count);
+	return only_verify ? "" : "Leaf [count: " + to_string(count) + ", row IDs: " + str + "] \n";
 }
 
 BlockPointer Leaf::Serialize(const ART &art, MetaBlockWriter &writer) const {
@@ -366,6 +363,7 @@ void Leaf::Vacuum(ART &art) {
 	auto &allocator = Node::GetAllocator(art, NType::LEAF_SEGMENT);
 	if (allocator.NeedsVacuum(row_ids.ptr)) {
 		row_ids.ptr.SetPtr(allocator.VacuumPointer(row_ids.ptr));
+		row_ids.ptr.type = (uint8_t)NType::LEAF_SEGMENT;
 	}
 
 	auto ptr = row_ids.ptr;
@@ -374,6 +372,7 @@ void Leaf::Vacuum(ART &art) {
 		ptr = segment.next;
 		if (ptr.IsSet() && allocator.NeedsVacuum(ptr)) {
 			segment.next.SetPtr(allocator.VacuumPointer(ptr));
+			segment.next.type = (uint8_t)NType::LEAF_SEGMENT;
 			ptr = segment.next;
 		}
 	}

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

@@ -15,6 +15,16 @@ LeafSegment &LeafSegment::New(ART &art, Node &node) {
 	return segment;
 }
 
+void LeafSegment::Free(ART &art, Node &node) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	// free next segment
+	auto next_segment = LeafSegment::Get(art, node).next;
+	Node::Free(art, next_segment);
+}
+
 LeafSegment &LeafSegment::Append(ART &art, uint32_t &count, const row_t row_id) {
 
 	reference<LeafSegment> segment(*this);

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

@@ -69,6 +69,9 @@ void Node::Free(ART &art, Node &node) {
 
 		// free the prefixes and children of the nodes
 		switch (type) {
+		case NType::LEAF_SEGMENT:
+			LeafSegment::Free(art, node);
+			break;
 		case NType::LEAF:
 			Leaf::Free(art, node);
 			break;
@@ -159,65 +162,57 @@ void Node::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
 optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet() && !IsSwizzled());
 
 	optional_ptr<Node> child;
 	switch (DecodeARTNodeType()) {
-	case NType::NODE_4: {
+	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_16: {
+	case NType::NODE_16:
 		child = Node16::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_48: {
+	case NType::NODE_48:
 		child = Node48::Get(art, *this).GetChild(byte);
 		break;
-	}
-	case NType::NODE_256: {
+	case NType::NODE_256:
 		child = Node256::Get(art, *this).GetChild(byte);
 		break;
-	}
 	default:
 		throw InternalException("Invalid node type for GetChild.");
 	}
 
-	// unswizzle the ART node before returning it
+	// deserialize the ART node before returning it
 	if (child && child->IsSwizzled()) {
 		child->Deserialize(art);
 	}
 	return child;
 }
 
-optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte) const {
+optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deserialize) const {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet() && !IsSwizzled());
 
 	optional_ptr<Node> child;
 	switch (DecodeARTNodeType()) {
-	case NType::NODE_4: {
+	case NType::NODE_4:
 		child = Node4::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_16: {
+	case NType::NODE_16:
 		child = Node16::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_48: {
+	case NType::NODE_48:
 		child = Node48::Get(art, *this).GetNextChild(byte);
 		break;
-	}
-	case NType::NODE_256: {
+	case NType::NODE_256:
 		child = Node256::Get(art, *this).GetNextChild(byte);
 		break;
-	}
 	default:
 		throw InternalException("Invalid node type for GetNextChild.");
 	}
 
-	// unswizzle the ART node before returning it
-	if (child && child->IsSwizzled()) {
+	// deserialize the ART node before returning it
+	if (child && deserialize && child->IsSwizzled()) {
 		child->Deserialize(art);
 	}
 	return child;
@@ -260,10 +255,11 @@ void Node::Deserialize(ART &art) {
 	type = reader.Read<uint8_t>();
 	swizzle_flag = 0;
 
-	auto type = DecodeARTNodeType();
-	SetPtr(Node::GetAllocator(art, type).New());
+	auto decoded_type = DecodeARTNodeType();
+	SetPtr(Node::GetAllocator(art, decoded_type).New());
+	type = (uint8_t)decoded_type;
 
-	switch (type) {
+	switch (decoded_type) {
 	case NType::LEAF:
 		return Leaf::Get(art, *this).Deserialize(art, reader);
 	case NType::NODE_4:
@@ -283,28 +279,43 @@ void Node::Deserialize(ART &art) {
 // Utility
 //===--------------------------------------------------------------------===//
 
-string Node::ToString(ART &art) const {
+string Node::VerifyAndToString(ART &art, const bool only_verify) {
 
-	D_ASSERT(!IsSwizzled());
+	D_ASSERT(IsSet());
+	if (IsSwizzled()) {
+		return only_verify ? "" : "swizzled";
+	}
 
-	if (DecodeARTNodeType() == NType::LEAF) {
-		return Leaf::Get(art, *this).ToString(art);
+	auto type = DecodeARTNodeType();
+	if (type == NType::LEAF) {
+		auto str = Leaf::Get(art, *this).VerifyAndToString(art, only_verify);
+		return only_verify ? "" : "\n" + str;
 	}
 
 	string str = "Node" + to_string(GetCapacity()) + ": [";
 
+	idx_t child_count = 0;
 	uint8_t byte = 0;
-	auto child = GetNextChild(art, byte);
+	auto child = GetNextChild(art, byte, false);
 	while (child) {
-		str += "(" + to_string(byte) + ", " + child->ToString(art) + ")";
-		if (byte == NumericLimits<uint8_t>::Maximum()) {
-			break;
+		child_count++;
+		if (child->IsSwizzled()) {
+			if (!only_verify) {
+				str += "(swizzled)";
+			}
+		} else {
+			str += "(" + to_string(byte) + ", " + child->VerifyAndToString(art, only_verify) + ")";
+			if (byte == NumericLimits<uint8_t>::Maximum()) {
+				break;
+			}
 		}
 		byte++;
-		child = GetNextChild(art, byte);
+		child = GetNextChild(art, byte, false);
 	}
 
-	return str + "]";
+	// ensure that the child count is at least two
+	D_ASSERT(child_count > 1);
+	return only_verify ? "" : "\n" + str + "]";
 }
 
 idx_t Node::GetCapacity() const {
@@ -567,6 +578,7 @@ void Node::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
 	needs_vacuum = flags.vacuum_flags[node.type - 1] && allocator.NeedsVacuum(node);
 	if (needs_vacuum) {
 		node.SetPtr(allocator.VacuumPointer(node));
+		node.type = (uint8_t)type;
 	}
 
 	switch (type) {

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

@@ -60,6 +60,7 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 	n16.prefix.Move(n48.prefix);
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
 			n16.key[n16.count] = i;
 			n16.children[n16.count] = n48.children[n48.child_index[i]];
@@ -160,6 +161,7 @@ optional_ptr<Node> Node16::GetChild(const uint8_t byte) {
 
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}
@@ -171,6 +173,7 @@ optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] >= byte) {
 			byte = key[i];
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}

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

@@ -83,6 +83,7 @@ void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node c
 	D_ASSERT(!n256.children[byte].IsSet());
 
 	n256.count++;
+	D_ASSERT(n256.count <= Node::NODE_256_CAPACITY);
 	n256.children[byte] = child;
 }
 

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

@@ -37,6 +37,7 @@ Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
 	auto &n4 = Node4::New(art, node4);
 	auto &n16 = Node16::Get(art, node16);
 
+	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
 	n4.count = n16.count;
 	n4.prefix.Move(n16.prefix);
 
@@ -145,6 +146,7 @@ optional_ptr<Node> Node4::GetChild(const uint8_t byte) {
 
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}
@@ -156,6 +158,7 @@ optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] >= byte) {
 			byte = key[i];
+			D_ASSERT(children[i].IsSet());
 			return &children[i];
 		}
 	}

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

@@ -85,6 +85,7 @@ Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 	n48.prefix.Move(n256.prefix);
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		D_ASSERT(n48.count <= Node::NODE_48_CAPACITY);
 		if (n256.children[i].IsSet()) {
 			n48.child_index[i] = n48.count;
 			n48.children[n48.count] = n256.children[i];
@@ -168,6 +169,7 @@ optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
 	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
 			byte = i;
+			D_ASSERT(children[child_index[i]].IsSet());
 			return &children[child_index[i]];
 		}
 	}