duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -1,34 +1,38 @@
 #include "duckdb/execution/index/art/art.hpp"
 
 #include "duckdb/common/types/conflict_manager.hpp"
+#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_key.hpp"
+#include "duckdb/execution/index/art/base_leaf.hpp"
+#include "duckdb/execution/index/art/base_node.hpp"
 #include "duckdb/execution/index/art/iterator.hpp"
 #include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/execution/index/art/node4.hpp"
+#include "duckdb/execution/index/art/node256_leaf.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
+#include "duckdb/optimizer/matcher/expression_matcher.hpp"
+#include "duckdb/planner/expression/bound_between_expression.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/storage/arena_allocator.hpp"
 #include "duckdb/storage/metadata/metadata_reader.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
-#include "duckdb/optimizer/matcher/expression_matcher.hpp"
 
 namespace duckdb {
 
 struct ARTIndexScanState : public IndexScanState {
-
-	//! Scan predicates (single predicate scan or range scan)
+	//! The predicates to scan.
+	//! A single predicate for point lookups, and two predicates for range scans.
 	Value values[2];
-	//! Expressions of the scan predicates
+	//! The expressions over the scan predicates.
 	ExpressionType expressions[2];
 	bool checked = false;
-	//! All scanned row IDs
-	vector<row_t> result_ids;
-	Iterator iterator;
+	//! All scanned row IDs.
+	unsafe_vector<row_t> row_ids;
 };
 
 //===--------------------------------------------------------------------===//
@@ -37,40 +41,13 @@ struct ARTIndexScanState : public IndexScanState {
 
 ART::ART(const string &name, const IndexConstraintType index_constraint_type, const vector<column_t> &column_ids,
          TableIOManager &table_io_manager, const vector<unique_ptr<Expression>> &unbound_expressions,
-         AttachedDatabase &db, const shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr,
+         AttachedDatabase &db,
+         const shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr,
          const IndexStorageInfo &info)
     : BoundIndex(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
       allocators(allocators_ptr), owns_data(false) {
 
-	// initialize all allocators
-	if (!allocators) {
-		owns_data = true;
-		auto &block_manager = table_io_manager.GetIndexBlockManager();
-
-		array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT> allocator_array = {
-		    make_uniq<FixedSizeAllocator>(sizeof(Prefix), block_manager),
-		    make_uniq<FixedSizeAllocator>(sizeof(Leaf), block_manager),
-		    make_uniq<FixedSizeAllocator>(sizeof(Node4), block_manager),
-		    make_uniq<FixedSizeAllocator>(sizeof(Node16), block_manager),
-		    make_uniq<FixedSizeAllocator>(sizeof(Node48), block_manager),
-		    make_uniq<FixedSizeAllocator>(sizeof(Node256), block_manager)};
-		allocators =
-		    make_shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>>(std::move(allocator_array));
-	}
-
-	// deserialize lazily
-	if (info.IsValid()) {
-
-		if (!info.root_block_ptr.IsValid()) {
-			InitAllocators(info);
-
-		} else {
-			// old storage file
-			Deserialize(info.root_block_ptr);
-		}
-	}
-
-	// validate the types of the key columns
+	// FIXME: Use the new byte representation function to support nested types.
 	for (idx_t i = 0; i < types.size(); i++) {
 		switch (types[i]) {
 		case PhysicalType::BOOL:
@@ -92,28 +69,61 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co
 			throw InvalidTypeException(logical_types[i], "Invalid type for index key.");
 		}
 	}
+
+	// Initialize the allocators.
+	SetPrefixCount(info);
+	if (!allocators) {
+		owns_data = true;
+		auto prefix_size = NumericCast<idx_t>(prefix_count) + NumericCast<idx_t>(Prefix::METADATA_SIZE);
+		auto &block_manager = table_io_manager.GetIndexBlockManager();
+
+		array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT> allocator_array = {
+		    make_unsafe_uniq<FixedSizeAllocator>(prefix_size, block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Leaf), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node4), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node16), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node48), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node256), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node7Leaf), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node15Leaf), block_manager),
+		    make_unsafe_uniq<FixedSizeAllocator>(sizeof(Node256Leaf), block_manager),
+		};
+		allocators =
+		    make_shared_ptr<array<unsafe_unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>>(std::move(allocator_array));
+	}
+
+	if (!info.IsValid()) {
+		// We create a new ART.
+		return;
+	}
+
+	if (info.root_block_ptr.IsValid()) {
+		// Backwards compatibility.
+		Deserialize(info.root_block_ptr);
+		return;
+	}
+
+	// Set the root node and initialize the allocators.
+	tree.Set(info.root);
+	InitAllocators(info);
 }
 
 //===--------------------------------------------------------------------===//
-// Initialize Predicate Scans
+// Initialize Scans
 //===--------------------------------------------------------------------===//
 
-//! Initialize a single predicate scan on the index with the given expression and column IDs
-static unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
+static unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Value &value,
                                                                 const ExpressionType expression_type) {
-	// initialize point lookup
 	auto result = make_uniq<ARTIndexScanState>();
 	result->values[0] = value;
 	result->expressions[0] = expression_type;
 	return std::move(result);
 }
 
-//! Initialize a two predicate scan on the index with the given expression and column IDs
-static unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction, const Value &low_value,
+static unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Value &low_value,
                                                               const ExpressionType low_expression_type,
                                                               const Value &high_value,
                                                               const ExpressionType high_expression_type) {
-	// initialize range lookup
 	auto result = make_uniq<ARTIndexScanState>();
 	result->values[0] = low_value;
 	result->expressions[0] = low_expression_type;
@@ -122,64 +132,64 @@ static unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction
 	return std::move(result);
 }
 
-unique_ptr<IndexScanState> ART::TryInitializeScan(const Transaction &transaction, const Expression &index_expr,
-                                                  const Expression &filter_expr) {
-
+unique_ptr<IndexScanState> ART::TryInitializeScan(const Expression &expr, const Expression &filter_expr) {
 	Value low_value, high_value, equal_value;
 	ExpressionType low_comparison_type = ExpressionType::INVALID, high_comparison_type = ExpressionType::INVALID;
-	// try to find a matching index for any of the filter expressions
 
-	// create a matcher for a comparison with a constant
+	// Try to find a matching index for any of the filter expressions.
 	ComparisonExpressionMatcher matcher;
-	// match on a comparison type
+	// Match on a comparison type.
 	matcher.expr_type = make_uniq<ComparisonExpressionTypeMatcher>();
-	// match on a constant comparison with the indexed expression
-	matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(index_expr));
+	// Match on a constant comparison with the indexed expression.
+	matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(expr));
 	matcher.matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-
 	matcher.policy = SetMatcher::Policy::UNORDERED;
 
 	vector<reference<Expression>> bindings;
-	if (matcher.Match(const_cast<Expression &>(filter_expr), bindings)) { // NOLINT: Match does not alter the expr
-		// range or equality comparison with constant value
-		// we can use our index here
-		// bindings[0] = the expression
-		// bindings[1] = the index expression
-		// bindings[2] = the constant
+	auto filter_match =
+	    matcher.Match(const_cast<Expression &>(filter_expr), bindings); // NOLINT: Match does not alter the expr.
+	if (filter_match) {
+		// This is a range or equality comparison with a constant value, so we can use the index.
+		// 		bindings[0] = the expression
+		// 		bindings[1] = the index expression
+		// 		bindings[2] = the constant
 		auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
 		auto constant_value = bindings[2].get().Cast<BoundConstantExpression>().value;
 		auto comparison_type = comparison.type;
+
 		if (comparison.left->type == ExpressionType::VALUE_CONSTANT) {
-			// the expression is on the right side, we flip them around
+			// The expression is on the right side, we flip the comparison expression.
 			comparison_type = FlipComparisonExpression(comparison_type);
 		}
+
 		if (comparison_type == ExpressionType::COMPARE_EQUAL) {
-			// equality value
-			// equality overrides any other bounds so we just break here
+			// An equality value overrides any other bounds.
 			equal_value = constant_value;
 		} else if (comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
 		           comparison_type == ExpressionType::COMPARE_GREATERTHAN) {
-			// greater than means this is a lower bound
+			// This is a lower bound.
 			low_value = constant_value;
 			low_comparison_type = comparison_type;
 		} else {
-			// smaller than means this is an upper bound
+			// This is an upper bound.
 			high_value = constant_value;
 			high_comparison_type = comparison_type;
 		}
+
 	} else if (filter_expr.type == ExpressionType::COMPARE_BETWEEN) {
-		// BETWEEN expression
 		auto &between = filter_expr.Cast<BoundBetweenExpression>();
-		if (!between.input->Equals(index_expr)) {
-			// expression doesn't match the index expression
+		if (!between.input->Equals(expr)) {
+			// The expression does not match the index expression.
 			return nullptr;
 		}
+
 		if (between.lower->type != ExpressionType::VALUE_CONSTANT ||
 		    between.upper->type != ExpressionType::VALUE_CONSTANT) {
-			// not a constant comparison
+			// Not a constant expression.
 			return nullptr;
 		}
-		low_value = (between.lower->Cast<BoundConstantExpression>()).value;
+
+		low_value = between.lower->Cast<BoundConstantExpression>().value;
 		low_comparison_type = between.lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
 		                                              : ExpressionType::COMPARE_GREATERTHAN;
 		high_value = (between.upper->Cast<BoundConstantExpression>()).value;
@@ -187,165 +197,177 @@ unique_ptr<IndexScanState> ART::TryInitializeScan(const Transaction &transaction
 		    between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
 	}
 
-	if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
-		// we can scan this index using this predicate: try a scan
-		unique_ptr<IndexScanState> index_state;
-		if (!equal_value.IsNull()) {
-			// equality predicate
-			index_state = InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
-		} else if (!low_value.IsNull() && !high_value.IsNull()) {
-			// two-sided predicate
-			index_state = InitializeScanTwoPredicates(transaction, low_value, low_comparison_type, high_value,
-			                                          high_comparison_type);
-		} else if (!low_value.IsNull()) {
-			// less than predicate
-			index_state = InitializeScanSinglePredicate(transaction, low_value, low_comparison_type);
-		} else {
-			D_ASSERT(!high_value.IsNull());
-			index_state = InitializeScanSinglePredicate(transaction, high_value, high_comparison_type);
-		}
-		return index_state;
+	// We cannot use an index scan.
+	if (equal_value.IsNull() && low_value.IsNull() && high_value.IsNull()) {
+		return nullptr;
 	}
-	return nullptr;
+
+	// Initialize the index scan state and return it.
+	if (!equal_value.IsNull()) {
+		// Equality predicate.
+		return InitializeScanSinglePredicate(equal_value, ExpressionType::COMPARE_EQUAL);
+	}
+	if (!low_value.IsNull() && !high_value.IsNull()) {
+		// Two-sided predicate.
+		return InitializeScanTwoPredicates(low_value, low_comparison_type, high_value, high_comparison_type);
+	}
+	if (!low_value.IsNull()) {
+		// Less-than predicate.
+		return InitializeScanSinglePredicate(low_value, low_comparison_type);
+	}
+	// Greater-than predicate.
+	return InitializeScanSinglePredicate(high_value, high_comparison_type);
 }
 
 //===--------------------------------------------------------------------===//
-// Keys
+// ART Keys
 //===--------------------------------------------------------------------===//
 
-template <class T>
-static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector<ARTKey> &keys) {
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
-
+template <class T, bool IS_NOT_NULL>
+static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, unsafe_vector<ARTKey> &keys) {
 	D_ASSERT(keys.size() >= count);
-	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
+
+	UnifiedVectorFormat data;
+	input.ToUnifiedFormat(count, data);
+	auto input_data = UnifiedVectorFormat::GetData<T>(data);
+
 	for (idx_t i = 0; i < count; i++) {
-		auto idx = idata.sel->get_index(i);
-		if (idata.validity.RowIsValid(idx)) {
-			ARTKey::CreateARTKey<T>(allocator, input.GetType(), keys[i], input_data[idx]);
-		} else {
-			// we need to possibly reset the former key value in the keys vector
-			keys[i] = ARTKey();
+		auto idx = data.sel->get_index(i);
+		if (IS_NOT_NULL || data.validity.RowIsValid(idx)) {
+			ARTKey::CreateARTKey<T>(allocator, keys[i], input_data[idx]);
+			continue;
 		}
+
+		// We need to reset the key value in the reusable keys vector.
+		keys[i] = ARTKey();
 	}
 }
 
-template <class T>
-static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector<ARTKey> &keys) {
-	UnifiedVectorFormat idata;
-	input.ToUnifiedFormat(count, idata);
+template <class T, bool IS_NOT_NULL>
+static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, unsafe_vector<ARTKey> &keys) {
+	UnifiedVectorFormat data;
+	input.ToUnifiedFormat(count, data);
+	auto input_data = UnifiedVectorFormat::GetData<T>(data);
 
-	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
 	for (idx_t i = 0; i < count; i++) {
-		auto idx = idata.sel->get_index(i);
-
-		// key is not NULL (no previous column entry was NULL)
-		if (!keys[i].Empty()) {
-			if (!idata.validity.RowIsValid(idx)) {
-				// this column entry is NULL, set whole key to NULL
-				keys[i] = ARTKey();
-			} else {
-				auto other_key = ARTKey::CreateARTKey<T>(allocator, input.GetType(), input_data[idx]);
-				keys[i].ConcatenateARTKey(allocator, other_key);
-			}
+		auto idx = data.sel->get_index(i);
+
+		if (IS_NOT_NULL) {
+			auto other_key = ARTKey::CreateARTKey<T>(allocator, input_data[idx]);
+			keys[i].Concat(allocator, other_key);
+			continue;
+		}
+
+		// A previous column entry was NULL.
+		if (keys[i].Empty()) {
+			continue;
 		}
+
+		// This column entry is NULL, so we set the whole key to NULL.
+		if (!data.validity.RowIsValid(idx)) {
+			keys[i] = ARTKey();
+			continue;
+		}
+
+		// Concatenate the keys.
+		auto other_key = ARTKey::CreateARTKey<T>(allocator, input_data[idx]);
+		keys[i].Concat(allocator, other_key);
 	}
 }
 
-void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<ARTKey> &keys) {
-	// generate keys for the first input column
+template <bool IS_NOT_NULL>
+void GenerateKeysInternal(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
 	switch (input.data[0].GetType().InternalType()) {
 	case PhysicalType::BOOL:
-		TemplatedGenerateKeys<bool>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<bool, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT8:
-		TemplatedGenerateKeys<int8_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int8_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT16:
-		TemplatedGenerateKeys<int16_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int16_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT32:
-		TemplatedGenerateKeys<int32_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int32_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT64:
-		TemplatedGenerateKeys<int64_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int64_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT128:
-		TemplatedGenerateKeys<hugeint_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<hugeint_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedGenerateKeys<uint8_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint8_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedGenerateKeys<uint16_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint16_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedGenerateKeys<uint32_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint32_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedGenerateKeys<uint64_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint64_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT128:
-		TemplatedGenerateKeys<uhugeint_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uhugeint_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedGenerateKeys<float>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<float, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedGenerateKeys<double>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<double, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedGenerateKeys<string_t>(allocator, input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<string_t, IS_NOT_NULL>(allocator, input.data[0], input.size(), keys);
 		break;
 	default:
 		throw InternalException("Invalid type for index");
 	}
 
+	// We concatenate the keys for each remaining column of a compound key.
 	for (idx_t i = 1; i < input.ColumnCount(); i++) {
-		// for each of the remaining columns, concatenate
 		switch (input.data[i].GetType().InternalType()) {
 		case PhysicalType::BOOL:
-			ConcatenateKeys<bool>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<bool, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT8:
-			ConcatenateKeys<int8_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<int8_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT16:
-			ConcatenateKeys<int16_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<int16_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT32:
-			ConcatenateKeys<int32_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<int32_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT64:
-			ConcatenateKeys<int64_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<int64_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT128:
-			ConcatenateKeys<hugeint_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<hugeint_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT8:
-			ConcatenateKeys<uint8_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<uint8_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT16:
-			ConcatenateKeys<uint16_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<uint16_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT32:
-			ConcatenateKeys<uint32_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<uint32_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT64:
-			ConcatenateKeys<uint64_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<uint64_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT128:
-			ConcatenateKeys<uhugeint_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<uhugeint_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::FLOAT:
-			ConcatenateKeys<float>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<float, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::DOUBLE:
-			ConcatenateKeys<double>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<double, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::VARCHAR:
-			ConcatenateKeys<string_t>(allocator, input.data[i], input.size(), keys);
+			ConcatenateKeys<string_t, IS_NOT_NULL>(allocator, input.data[i], input.size(), keys);
 			break;
 		default:
 			throw InternalException("Invalid type for index");
@@ -353,195 +375,168 @@ void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<ARTKe
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Construct from sorted data (only during CREATE (UNIQUE) INDEX statements)
-//===--------------------------------------------------------------------===//
+template <>
+void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
+	GenerateKeysInternal<false>(allocator, input, keys);
+}
 
-struct KeySection {
-	KeySection(idx_t start_p, idx_t end_p, idx_t depth_p, data_t key_byte_p)
-	    : start(start_p), end(end_p), depth(depth_p), key_byte(key_byte_p) {};
-	KeySection(idx_t start_p, idx_t end_p, vector<ARTKey> &keys, KeySection &key_section)
-	    : start(start_p), end(end_p), depth(key_section.depth + 1), key_byte(keys[end_p].data[key_section.depth]) {};
-	idx_t start;
-	idx_t end;
-	idx_t depth;
-	data_t key_byte;
-};
+template <>
+void ART::GenerateKeys<true>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector<ARTKey> &keys) {
+	GenerateKeysInternal<true>(allocator, input, keys);
+}
 
-void GetChildSections(vector<KeySection> &child_sections, vector<ARTKey> &keys, KeySection &key_section) {
+void ART::GenerateKeyVectors(ArenaAllocator &allocator, DataChunk &input, Vector &row_ids, unsafe_vector<ARTKey> &keys,
+                             unsafe_vector<ARTKey> &row_id_keys) {
+	GenerateKeys<>(allocator, input, keys);
 
-	idx_t child_start_idx = key_section.start;
-	for (idx_t i = key_section.start + 1; i <= key_section.end; i++) {
-		if (keys[i - 1].data[key_section.depth] != keys[i].data[key_section.depth]) {
-			child_sections.emplace_back(child_start_idx, i - 1, keys, key_section);
-			child_start_idx = i;
-		}
-	}
-	child_sections.emplace_back(child_start_idx, key_section.end, keys, key_section);
+	DataChunk row_id_chunk;
+	row_id_chunk.Initialize(Allocator::DefaultAllocator(), vector<LogicalType> {LogicalType::ROW_TYPE}, input.size());
+	row_id_chunk.data[0].Reference(row_ids);
+	row_id_chunk.SetCardinality(input.size());
+	GenerateKeys<>(allocator, row_id_chunk, row_id_keys);
 }
 
-bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySection &key_section,
-               bool &has_constraint) {
+//===--------------------------------------------------------------------===//
+// Construct from sorted data.
+//===--------------------------------------------------------------------===//
 
-	D_ASSERT(key_section.start < keys.size());
-	D_ASSERT(key_section.end < keys.size());
-	D_ASSERT(key_section.start <= key_section.end);
+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 &start_key = keys[key_section.start];
-	auto &end_key = keys[key_section.end];
+	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_start = key_section.depth;
-	while (start_key.len != key_section.depth &&
-	       start_key.ByteMatches(end_key, UnsafeNumericCast<uint32_t>(key_section.depth))) {
-		key_section.depth++;
+	// 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++;
 	}
 
-	// we reached a leaf, i.e. all the bytes of start_key and end_key match
-	if (start_key.len == key_section.depth) {
-		// end_idx is inclusive
-		auto num_row_ids = key_section.end - key_section.start + 1;
-
-		// check for possible constraint violation
-		auto single_row_id = num_row_ids == 1;
-		if (has_constraint && !single_row_id) {
+	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(node);
-		Prefix::New(art, ref_node, start_key, UnsafeNumericCast<uint32_t>(prefix_start),
-		            UnsafeNumericCast<uint32_t>(start_key.len - prefix_start));
-		if (single_row_id) {
-			Leaf::New(ref_node, row_ids[key_section.start]);
+		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 {
-			Leaf::New(art, ref_node, row_ids + key_section.start, num_row_ids);
+			Leaf::New(*this, ref, row_ids, section.start, row_id_count);
 		}
 		return true;
 	}
 
-	// create a new node and recurse
-
-	// we will find at least two child entries of this node, otherwise we'd have reached a leaf
-	vector<KeySection> child_sections;
-	GetChildSections(child_sections, keys, key_section);
+	// Create a new node and recurse.
+	unsafe_vector<ARTKeySection> children;
+	section.GetChildSections(children, keys);
 
-	// set the prefix
-	reference<Node> ref_node(node);
-	auto prefix_length = key_section.depth - prefix_start;
-	Prefix::New(art, ref_node, start_key, UnsafeNumericCast<uint32_t>(prefix_start),
-	            UnsafeNumericCast<uint32_t>(prefix_length));
+	// Create the prefix.
+	reference<Node> ref(node);
+	auto prefix_length = section.depth - prefix_depth;
+	Prefix::New(*this, ref, start, prefix_depth, prefix_length);
 
-	// set the node
-	auto node_type = Node::GetARTNodeTypeByCount(child_sections.size());
-	Node::New(art, ref_node, node_type);
-
-	// recurse on each child section
-	for (auto &child_section : child_sections) {
+	// Create the node.
+	Node::New(*this, ref, Node::GetNodeType(children.size()));
+	for (auto &child : children) {
 		Node new_child;
-		auto no_violation = Construct(art, keys, row_ids, new_child, child_section, has_constraint);
-		Node::InsertChild(art, ref_node, child_section.key_byte, new_child);
-		if (!no_violation) {
+		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::ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_identifiers) {
-
-	// prepare the row_identifiers
-	row_identifiers.Flatten(count);
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-
-	auto key_section = KeySection(0, count - 1, 0, 0);
-	auto has_constraint = IsUnique();
-	if (!Construct(*this, keys, row_ids, tree, key_section, has_constraint)) {
+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
-	D_ASSERT(!VerifyAndToStringInternal(true).empty());
-	for (idx_t i = 0; i < count; i++) {
-		D_ASSERT(!keys[i].Empty());
-		auto leaf = Lookup(tree, keys[i], 0);
-		D_ASSERT(Leaf::ContainsRowId(*this, *leaf, row_ids[i]));
-	}
+	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 true;
 }
 
 //===--------------------------------------------------------------------===//
-// Insert / Verification / Constraint Checking
+// Insert and Constraint Checking
 //===--------------------------------------------------------------------===//
-ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 
+ErrorData ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-	D_ASSERT(logical_types[0] == input.data[0].GetType());
+	auto row_count = input.size();
 
-	// generate the keys for the given input
-	ArenaAllocator arena_allocator(BufferAllocator::Get(db));
-	vector<ARTKey> keys(input.size());
-	GenerateKeys(arena_allocator, input, keys);
-
-	// get the corresponding row IDs
-	row_ids.Flatten(input.size());
-	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
+	ArenaAllocator allocator(BufferAllocator::Get(db));
+	unsafe_vector<ARTKey> keys(row_count);
+	unsafe_vector<ARTKey> row_id_keys(row_count);
+	GenerateKeyVectors(allocator, input, row_ids, keys, row_id_keys);
 
-	// now insert the elements into the index
+	// Insert the entries into the index.
 	idx_t failed_index = DConstants::INVALID_INDEX;
-	for (idx_t i = 0; i < input.size(); i++) {
+	auto was_empty = !tree.HasMetadata();
+	for (idx_t i = 0; i < row_count; i++) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-
-		row_t row_id = row_identifiers[i];
-		if (!Insert(tree, keys[i], 0, row_id)) {
-			// failed to insert because of constraint violation
+		if (!Insert(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus())) {
+			// Insertion failure due to a constraint violation.
 			failed_index = i;
 			break;
 		}
 	}
 
-	// failed to insert because of constraint violation: remove previously inserted entries
+	// Remove any previously inserted entries.
 	if (failed_index != DConstants::INVALID_INDEX) {
 		for (idx_t i = 0; i < failed_index; i++) {
 			if (keys[i].Empty()) {
 				continue;
 			}
-			row_t row_id = row_identifiers[i];
-			Erase(tree, keys[i], 0, row_id);
+			Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
 		}
 	}
 
+	if (was_empty) {
+		// All nodes are in-memory.
+		VerifyAllocationsInternal();
+	}
+
 	if (failed_index != DConstants::INVALID_INDEX) {
-		return ErrorData(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"",
-		                                     AppendRowError(input, failed_index)));
+		auto msg = AppendRowError(input, failed_index);
+		return ErrorData(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"", msg));
 	}
 
 #ifdef DEBUG
-	for (idx_t i = 0; i < input.size(); i++) {
+	for (idx_t i = 0; i < row_count; i++) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-
-		auto leaf = Lookup(tree, keys[i], 0);
-		D_ASSERT(Leaf::ContainsRowId(*this, *leaf, row_identifiers[i]));
+		D_ASSERT(Lookup(tree, keys[i], 0));
 	}
 #endif
-
 	return ErrorData();
 }
 
-ErrorData ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
-	DataChunk expression_result;
-	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
-
-	// first resolve the expressions for the index
-	ExecuteExpressions(appended_data, expression_result);
-
-	// now insert into the index
-	return Insert(lock, expression_result, row_identifiers);
+ErrorData ART::Append(IndexLock &lock, DataChunk &input, Vector &row_ids) {
+	// Execute all column expressions before inserting the data chunk.
+	DataChunk expr_chunk;
+	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
+	ExecuteExpressions(input, expr_chunk);
+	return Insert(lock, expr_chunk, row_ids);
 }
 
 void ART::VerifyAppend(DataChunk &chunk) {
@@ -554,87 +549,102 @@ void ART::VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) {
 	CheckConstraintsForChunk(chunk, conflict_manager);
 }
 
-bool ART::InsertToLeaf(Node &leaf, const row_t &row_id) {
+void ART::InsertIntoEmpty(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
+                          const GateStatus status) {
+	D_ASSERT(depth <= key.len);
+	D_ASSERT(!node.HasMetadata());
 
-	if (IsUnique()) {
-		return false;
+	if (status == GateStatus::GATE_SET) {
+		Leaf::New(node, row_id.GetRowId());
+		return;
 	}
 
-	Leaf::Insert(*this, leaf, row_id);
-	return true;
+	reference<Node> ref(node);
+	auto count = key.len - depth;
+
+	Prefix::New(*this, ref, key, depth, count);
+	Leaf::New(ref, row_id.GetRowId());
 }
 
-bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
+bool ART::InsertIntoNode(Node &node, const ARTKey &key, const idx_t depth, const ARTKey &row_id,
+                         const GateStatus status) {
+	D_ASSERT(depth < key.len);
+	auto child = node.GetChildMutable(*this, key[depth]);
 
-	// node is currently empty, create a leaf here with the key
-	if (!node.HasMetadata()) {
-		D_ASSERT(depth <= key.len);
-		reference<Node> ref_node(node);
-		Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth),
-		            UnsafeNumericCast<uint32_t>(key.len - depth));
-		Leaf::New(ref_node, row_id);
-		return true;
+	// Recurse, if a child exists at key[depth].
+	if (child) {
+		D_ASSERT(child->HasMetadata());
+		bool success = Insert(*child, key, depth + 1, row_id, status);
+		node.ReplaceChild(*this, key[depth], *child);
+		return success;
 	}
 
-	auto node_type = node.GetType();
-
-	// insert the row ID into this leaf
-	if (node_type == NType::LEAF || node_type == NType::LEAF_INLINED) {
-		return InsertToLeaf(node, row_id);
+	// Create an inlined prefix at key[depth].
+	if (status == GateStatus::GATE_SET) {
+		Node remainder;
+		auto byte = key[depth];
+		auto success = Insert(remainder, key, depth + 1, row_id, status);
+		Node::InsertChild(*this, node, byte, remainder);
+		return success;
 	}
 
-	if (node_type != NType::PREFIX) {
-		D_ASSERT(depth < key.len);
-		auto child = node.GetChildMutable(*this, key[depth]);
+	// Insert an inlined leaf at key[depth].
+	Node leaf;
+	reference<Node> ref(leaf);
 
-		// recurse, if a child exists at key[depth]
-		if (child) {
-			bool success = Insert(*child, key, depth + 1, row_id);
-			node.ReplaceChild(*this, key[depth], *child);
-			return success;
-		}
-
-		// insert a new leaf node at key[depth]
-		Node leaf_node;
-		reference<Node> ref_node(leaf_node);
-		if (depth + 1 < key.len) {
-			Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth + 1),
-			            UnsafeNumericCast<uint32_t>(key.len - depth - 1));
-		}
-		Leaf::New(ref_node, row_id);
-		Node::InsertChild(*this, node, key[depth], leaf_node);
-		return true;
+	// Create the prefix.
+	if (depth + 1 < key.len) {
+		auto count = key.len - depth - 1;
+		Prefix::New(*this, ref, key, depth + 1, count);
 	}
 
-	// this is a prefix node, traverse
-	reference<Node> next_node(node);
-	auto mismatch_position = Prefix::TraverseMutable(*this, next_node, key, depth);
+	// Create the inlined leaf.
+	Leaf::New(ref, row_id.GetRowId());
+	Node::InsertChild(*this, node, key[depth], leaf);
+	return true;
+}
 
-	// prefix matches key
-	if (next_node.get().GetType() != NType::PREFIX) {
-		return Insert(next_node, key, depth, row_id);
+bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id, const GateStatus status) {
+	if (!node.HasMetadata()) {
+		InsertIntoEmpty(node, key, depth, row_id, status);
+		return true;
 	}
 
-	// prefix does not match the key, we need to create a new Node4; this new Node4 has two children,
-	// the remaining part of the prefix, and the new leaf
-	Node remaining_prefix;
-	auto prefix_byte = Prefix::GetByte(*this, next_node, mismatch_position);
-	Prefix::Split(*this, next_node, remaining_prefix, mismatch_position);
-	Node4::New(*this, next_node);
-
-	// insert remaining prefix
-	Node4::InsertChild(*this, next_node, prefix_byte, remaining_prefix);
+	// Enter a nested leaf.
+	if (status == GateStatus::GATE_NOT_SET && node.GetGateStatus() == GateStatus::GATE_SET) {
+		return Insert(node, row_id, 0, row_id, GateStatus::GATE_SET);
+	}
 
-	// insert new leaf
-	Node leaf_node;
-	reference<Node> ref_node(leaf_node);
-	if (depth + 1 < key.len) {
-		Prefix::New(*this, ref_node, key, UnsafeNumericCast<uint32_t>(depth + 1),
-		            UnsafeNumericCast<uint32_t>(key.len - depth - 1));
+	auto type = node.GetType();
+	switch (type) {
+	case NType::LEAF_INLINED: {
+		if (IsUnique()) {
+			return false;
+		}
+		Leaf::InsertIntoInlined(*this, node, row_id, depth, status);
+		return true;
+	}
+	case NType::LEAF: {
+		Leaf::TransformToNested(*this, node);
+		return Insert(node, key, depth, row_id, status);
+	}
+	case NType::NODE_7_LEAF:
+	case NType::NODE_15_LEAF:
+	case NType::NODE_256_LEAF: {
+		auto byte = key[Prefix::ROW_ID_COUNT];
+		Node::InsertChild(*this, node, byte);
+		return true;
+	}
+	case NType::NODE_4:
+	case NType::NODE_16:
+	case NType::NODE_48:
+	case NType::NODE_256:
+		return InsertIntoNode(node, key, depth, row_id, status);
+	case NType::PREFIX:
+		return Prefix::Insert(*this, node, key, depth, row_id, status);
+	default:
+		throw InternalException("Invalid node type for Insert.");
 	}
-	Leaf::New(ref_node, row_id);
-	Node4::InsertChild(*this, next_node, key[depth], leaf_node);
-	return true;
 }
 
 //===--------------------------------------------------------------------===//
@@ -649,356 +659,291 @@ void ART::CommitDrop(IndexLock &index_lock) {
 }
 
 void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
+	auto row_count = input.size();
 
-	DataChunk expression;
-	expression.Initialize(Allocator::DefaultAllocator(), logical_types);
+	DataChunk expr_chunk;
+	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
+	ExecuteExpressions(input, expr_chunk);
 
-	// first resolve the expressions
-	ExecuteExpressions(input, expression);
+	ArenaAllocator allocator(BufferAllocator::Get(db));
+	unsafe_vector<ARTKey> keys(row_count);
+	unsafe_vector<ARTKey> row_id_keys(row_count);
+	GenerateKeyVectors(allocator, expr_chunk, row_ids, keys, row_id_keys);
 
-	// then generate the keys for the given input
-	ArenaAllocator arena_allocator(BufferAllocator::Get(db));
-	vector<ARTKey> keys(expression.size());
-	GenerateKeys(arena_allocator, expression, keys);
-
-	// now erase the elements from the database
-	row_ids.Flatten(input.size());
-	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
-
-	for (idx_t i = 0; i < input.size(); i++) {
+	for (idx_t i = 0; i < row_count; i++) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-		Erase(tree, keys[i], 0, row_identifiers[i]);
+		Erase(tree, keys[i], 0, row_id_keys[i], tree.GetGateStatus());
+	}
+
+	if (!tree.HasMetadata()) {
+		// No more allocations.
+		VerifyAllocationsInternal();
 	}
 
 #ifdef DEBUG
-	// verify that we removed all row IDs
-	for (idx_t i = 0; i < input.size(); i++) {
+	for (idx_t i = 0; i < row_count; i++) {
 		if (keys[i].Empty()) {
 			continue;
 		}
-
 		auto leaf = Lookup(tree, keys[i], 0);
-		if (leaf) {
-			D_ASSERT(!Leaf::ContainsRowId(*this, *leaf, row_identifiers[i]));
+		if (leaf && leaf->GetType() == NType::LEAF_INLINED) {
+			D_ASSERT(leaf->GetRowId() != row_id_keys[i].GetRowId());
 		}
 	}
 #endif
 }
 
-void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
-
+void ART::Erase(Node &node, reference<const ARTKey> key, idx_t depth, reference<const ARTKey> row_id,
+                GateStatus status) {
 	if (!node.HasMetadata()) {
 		return;
 	}
 
-	// handle prefix
-	reference<Node> next_node(node);
-	if (next_node.get().GetType() == NType::PREFIX) {
-		Prefix::TraverseMutable(*this, next_node, key, depth);
-		if (next_node.get().GetType() == NType::PREFIX) {
+	// Traverse the prefix.
+	reference<Node> next(node);
+	if (next.get().GetType() == NType::PREFIX) {
+		Prefix::TraverseMutable(*this, next, key, depth);
+
+		// Prefixes don't match: nothing to erase.
+		if (next.get().GetType() == NType::PREFIX && next.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
 			return;
 		}
 	}
 
-	// delete a row ID from a leaf (root is leaf with possible prefix nodes)
-	if (next_node.get().GetType() == NType::LEAF || next_node.get().GetType() == NType::LEAF_INLINED) {
-		if (Leaf::Remove(*this, next_node, row_id)) {
+	//	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;
 	}
 
-	D_ASSERT(depth < key.len);
-	auto child = next_node.get().GetChildMutable(*this, key[depth]);
-	if (child) {
-		D_ASSERT(child->HasMetadata());
+	// Transform a deprecated leaf.
+	if (next.get().GetType() == NType::LEAF) {
+		D_ASSERT(status == GateStatus::GATE_NOT_SET);
+		Leaf::TransformToNested(*this, next);
+	}
 
-		auto temp_depth = depth + 1;
-		reference<Node> child_node(*child);
-		if (child_node.get().GetType() == NType::PREFIX) {
-			Prefix::TraverseMutable(*this, child_node, key, temp_depth);
-			if (child_node.get().GetType() == NType::PREFIX) {
-				return;
-			}
-		}
+	// 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);
+	}
 
-		if (child_node.get().GetType() == NType::LEAF || child_node.get().GetType() == NType::LEAF_INLINED) {
-			// leaf found, remove entry
-			if (Leaf::Remove(*this, child_node, row_id)) {
-				Node::DeleteChild(*this, next_node, node, key[depth]);
-			}
-			return;
+	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;
+	}
 
-		// recurse
-		Erase(*child, key, depth + 1, row_id);
-		next_node.get().ReplaceChild(*this, key[depth], *child);
+	auto child = next.get().GetChildMutable(*this, key.get()[depth]);
+	if (!child) {
+		// No child at the byte: nothing to erase.
+		return;
 	}
-}
 
-//===--------------------------------------------------------------------===//
-// Point Query (Equal)
-//===--------------------------------------------------------------------===//
+	// Transform a deprecated leaf.
+	if (child->GetType() == NType::LEAF) {
+		D_ASSERT(status == GateStatus::GATE_NOT_SET);
+		Leaf::TransformToNested(*this, *child);
+	}
 
-static ARTKey CreateKey(ArenaAllocator &allocator, PhysicalType type, Value &value) {
-	D_ASSERT(type == value.type().InternalType());
-	switch (type) {
-	case PhysicalType::BOOL:
-		return ARTKey::CreateARTKey<bool>(allocator, value.type(), value);
-	case PhysicalType::INT8:
-		return ARTKey::CreateARTKey<int8_t>(allocator, value.type(), value);
-	case PhysicalType::INT16:
-		return ARTKey::CreateARTKey<int16_t>(allocator, value.type(), value);
-	case PhysicalType::INT32:
-		return ARTKey::CreateARTKey<int32_t>(allocator, value.type(), value);
-	case PhysicalType::INT64:
-		return ARTKey::CreateARTKey<int64_t>(allocator, value.type(), value);
-	case PhysicalType::UINT8:
-		return ARTKey::CreateARTKey<uint8_t>(allocator, value.type(), value);
-	case PhysicalType::UINT16:
-		return ARTKey::CreateARTKey<uint16_t>(allocator, value.type(), value);
-	case PhysicalType::UINT32:
-		return ARTKey::CreateARTKey<uint32_t>(allocator, value.type(), value);
-	case PhysicalType::UINT64:
-		return ARTKey::CreateARTKey<uint64_t>(allocator, value.type(), value);
-	case PhysicalType::INT128:
-		return ARTKey::CreateARTKey<hugeint_t>(allocator, value.type(), value);
-	case PhysicalType::UINT128:
-		return ARTKey::CreateARTKey<uhugeint_t>(allocator, value.type(), value);
-	case PhysicalType::FLOAT:
-		return ARTKey::CreateARTKey<float>(allocator, value.type(), value);
-	case PhysicalType::DOUBLE:
-		return ARTKey::CreateARTKey<double>(allocator, value.type(), value);
-	case PhysicalType::VARCHAR:
-		return ARTKey::CreateARTKey<string_t>(allocator, value.type(), value);
-	default:
-		throw InternalException("Invalid type for the ART key");
+	// 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;
 	}
-}
 
-bool ART::SearchEqual(ARTKey &key, idx_t max_count, vector<row_t> &result_ids) {
+	auto temp_depth = depth + 1;
+	reference<Node> ref(*child);
 
-	auto leaf = Lookup(tree, key, 0);
-	if (!leaf) {
-		return true;
-	}
-	return Leaf::GetRowIds(*this, *leaf, result_ids, max_count);
-}
+	if (ref.get().GetType() == NType::PREFIX) {
+		Prefix::TraverseMutable(*this, ref, key, temp_depth);
 
-void ART::SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size) {
+		// Prefixes don't match: nothing to erase.
+		if (ref.get().GetType() == NType::PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
+			return;
+		}
+	}
 
-	// we need to look for a leaf
-	auto leaf_node = Lookup(tree, key, 0);
-	if (!leaf_node) {
-		result_size = 0;
+	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;
 	}
 
-	// we only perform index joins on PK/FK columns
-	D_ASSERT(leaf_node->GetType() == NType::LEAF_INLINED);
-	result_size = 1;
-	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);
+	}
 }
 
 //===--------------------------------------------------------------------===//
-// Lookup
+// Point and range lookups
 //===--------------------------------------------------------------------===//
 
-optional_ptr<const Node> ART::Lookup(const Node &node, const ARTKey &key, idx_t depth) {
+const unsafe_optional_ptr<const Node> ART::Lookup(const Node &node, const ARTKey &key, idx_t depth) {
+	reference<const Node> ref(node);
+	while (ref.get().HasMetadata()) {
 
-	reference<const Node> node_ref(node);
-	while (node_ref.get().HasMetadata()) {
+		// Return the leaf.
+		if (ref.get().IsAnyLeaf() || ref.get().GetGateStatus() == GateStatus::GATE_SET) {
+			return unsafe_optional_ptr<const Node>(ref.get());
+		}
 
-		// traverse prefix, if exists
-		reference<const Node> next_node(node_ref.get());
-		if (next_node.get().GetType() == NType::PREFIX) {
-			Prefix::Traverse(*this, next_node, key, depth);
-			if (next_node.get().GetType() == NType::PREFIX) {
+		// Traverse the prefix.
+		if (ref.get().GetType() == NType::PREFIX) {
+			Prefix::Traverse(*this, ref, key, depth);
+			if (ref.get().GetType() == NType::PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
+				// Prefix mismatch, return nullptr.
 				return nullptr;
 			}
+			continue;
 		}
 
-		if (next_node.get().GetType() == NType::LEAF || next_node.get().GetType() == NType::LEAF_INLINED) {
-			return &next_node.get();
-		}
-
+		// Get the child node.
 		D_ASSERT(depth < key.len);
-		auto child = next_node.get().GetChild(*this, key[depth]);
+		auto child = ref.get().GetChild(*this, key[depth]);
+
+		// No child at the matching byte, return nullptr.
 		if (!child) {
-			// prefix matches key, but no child at byte, ART/subtree does not contain key
 			return nullptr;
 		}
 
-		// lookup in child node
-		node_ref = *child;
-		D_ASSERT(node_ref.get().HasMetadata());
+		// Continue in the child.
+		ref = *child;
+		D_ASSERT(ref.get().HasMetadata());
 		depth++;
 	}
 
 	return nullptr;
 }
 
-//===--------------------------------------------------------------------===//
-// Greater Than and Less Than
-//===--------------------------------------------------------------------===//
+bool ART::SearchEqual(ARTKey &key, idx_t max_count, unsafe_vector<row_t> &row_ids) {
+	auto leaf = Lookup(tree, key, 0);
+	if (!leaf) {
+		return true;
+	}
 
-bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool equal, idx_t max_count, vector<row_t> &result_ids) {
+	Iterator it(*this);
+	it.FindMinimum(*leaf);
+	ARTKey empty_key = ARTKey();
+	return it.Scan(empty_key, max_count, row_ids, false);
+}
 
+bool ART::SearchGreater(ARTKey &key, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	if (!tree.HasMetadata()) {
 		return true;
 	}
-	Iterator &it = state.iterator;
 
-	// find the lowest value that satisfies the predicate
-	if (!it.art) {
-		it.art = this;
-		if (!it.LowerBound(tree, key, equal, 0)) {
-			// early-out, if the maximum value in the ART is lower than the lower bound
-			return true;
-		}
+	// Find the lowest value that satisfies the predicate.
+	Iterator it(*this);
+
+	// Early-out, if the maximum value in the ART is lower than the lower bound.
+	if (!it.LowerBound(tree, key, equal, 0)) {
+		return true;
 	}
 
-	// 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);
+	// We continue the scan. We do not check the bounds as any value following this value is
+	// greater and satisfies our predicate.
+	return it.Scan(ARTKey(), max_count, row_ids, false);
 }
 
-bool ART::SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool equal, idx_t max_count,
-                     vector<row_t> &result_ids) {
-
+bool ART::SearchLess(ARTKey &upper_bound, bool equal, idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	if (!tree.HasMetadata()) {
 		return true;
 	}
-	Iterator &it = state.iterator;
 
-	if (!it.art) {
-		it.art = this;
-		// find the minimum value in the ART: we start scanning from this value
-		it.FindMinimum(tree);
-		// early-out, if the minimum value is higher than the upper bound
-		if (it.current_key > upper_bound) {
-			return true;
-		}
+	// Find the minimum value in the ART: we start scanning from this value.
+	Iterator it(*this);
+	it.FindMinimum(tree);
+
+	// Early-out, if the minimum value is higher than the upper bound.
+	if (it.current_key.GreaterThan(upper_bound, equal, it.GetNestedDepth())) {
+		return true;
 	}
 
-	// now continue the scan until we reach the upper bound
-	return it.Scan(upper_bound, max_count, result_ids, equal);
+	// Continue the scan until we reach the upper bound.
+	return it.Scan(upper_bound, max_count, row_ids, equal);
 }
 
-//===--------------------------------------------------------------------===//
-// Closed Range Query
-//===--------------------------------------------------------------------===//
-
-bool ART::SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal,
-                           bool right_equal, idx_t max_count, vector<row_t> &result_ids) {
+bool ART::SearchCloseRange(ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal, bool right_equal, idx_t max_count,
+                           unsafe_vector<row_t> &row_ids) {
+	// Find the first node that satisfies the left predicate.
+	Iterator it(*this);
 
-	Iterator &it = state.iterator;
-
-	// find the first node that satisfies the left predicate
-	if (!it.art) {
-		it.art = this;
-		if (!it.LowerBound(tree, lower_bound, left_equal, 0)) {
-			// early-out, if the maximum value in the ART is lower than the lower bound
-			return true;
-		}
+	// Early-out, if the maximum value in the ART is lower than the lower bound.
+	if (!it.LowerBound(tree, lower_bound, left_equal, 0)) {
+		return true;
 	}
 
-	// now continue the scan until we reach the upper bound
-	return it.Scan(upper_bound, max_count, result_ids, right_equal);
+	// Continue the scan until we reach the upper bound.
+	return it.Scan(upper_bound, max_count, row_ids, right_equal);
 }
 
-bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, const idx_t max_count,
-               vector<row_t> &result_ids) {
-
+bool ART::Scan(IndexScanState &state, const idx_t max_count, unsafe_vector<row_t> &row_ids) {
 	auto &scan_state = 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(scan_state.values[0].type().InternalType() == types[0]);
 	ArenaAllocator arena_allocator(Allocator::Get(db));
-	auto key = CreateKey(arena_allocator, types[0], scan_state.values[0]);
+	auto key = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[0]);
 
 	if (scan_state.values[1].IsNull()) {
-
-		// single predicate
+		// Single predicate.
 		lock_guard<mutex> l(lock);
 		switch (scan_state.expressions[0]) {
 		case ExpressionType::COMPARE_EQUAL:
-			success = SearchEqual(key, max_count, row_ids);
-			break;
+			return SearchEqual(key, max_count, row_ids);
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			success = SearchGreater(scan_state, key, true, max_count, row_ids);
-			break;
+			return SearchGreater(key, true, max_count, row_ids);
 		case ExpressionType::COMPARE_GREATERTHAN:
-			success = SearchGreater(scan_state, key, false, max_count, row_ids);
-			break;
+			return SearchGreater(key, false, max_count, row_ids);
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			success = SearchLess(scan_state, key, true, max_count, row_ids);
-			break;
+			return SearchLess(key, true, max_count, row_ids);
 		case ExpressionType::COMPARE_LESSTHAN:
-			success = SearchLess(scan_state, key, false, max_count, row_ids);
-			break;
+			return SearchLess(key, false, max_count, row_ids);
 		default:
 			throw InternalException("Index scan type not implemented");
 		}
-
-	} else {
-
-		// two predicates
-		lock_guard<mutex> l(lock);
-
-		D_ASSERT(scan_state.values[1].type().InternalType() == types[0]);
-		auto upper_bound = CreateKey(arena_allocator, types[0], scan_state.values[1]);
-
-		bool left_equal = scan_state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-		bool right_equal = scan_state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
-		success = SearchCloseRange(scan_state, key, upper_bound, left_equal, right_equal, max_count, row_ids);
-	}
-
-	if (!success) {
-		return false;
-	}
-	if (row_ids.empty()) {
-		return true;
 	}
 
-	// sort the row ids
-	sort(row_ids.begin(), row_ids.end());
-	// duplicate eliminate the row ids and append them to the row ids of the state
-	result_ids.reserve(row_ids.size());
-
-	result_ids.push_back(row_ids[0]);
-	for (idx_t i = 1; i < row_ids.size(); i++) {
-		if (row_ids[i] != row_ids[i - 1]) {
-			result_ids.push_back(row_ids[i]);
-		}
-	}
-	return true;
+	// Two predicates.
+	lock_guard<mutex> l(lock);
+	D_ASSERT(scan_state.values[1].type().InternalType() == types[0]);
+	auto upper_bound = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[1]);
+	bool left_equal = scan_state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
+	bool right_equal = scan_state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
+	return SearchCloseRange(key, upper_bound, left_equal, right_equal, max_count, row_ids);
 }
 
 //===--------------------------------------------------------------------===//
-// More Verification / Constraint Checking
+// More Constraint Checking
 //===--------------------------------------------------------------------===//
 
-string ART::GenerateErrorKeyName(DataChunk &input, idx_t row) {
-
-	// FIXME: why exactly can we not pass the expression_chunk as an argument to this
-	// FIXME: function instead of re-executing?
-	// re-executing the expressions is not very fast, but we're going to throw, so we don't care
-	DataChunk expression_chunk;
-	expression_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expression_chunk);
+string ART::GenerateErrorKeyName(DataChunk &input, idx_t row_idx) {
+	DataChunk expr_chunk;
+	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
+	ExecuteExpressions(input, expr_chunk);
 
 	string key_name;
-	for (idx_t k = 0; k < expression_chunk.ColumnCount(); k++) {
+	for (idx_t k = 0; k < expr_chunk.ColumnCount(); k++) {
 		if (k > 0) {
 			key_name += ", ";
 		}
-		key_name += unbound_expressions[k]->GetName() + ": " + expression_chunk.data[k].GetValue(row).ToString();
+		key_name += unbound_expressions[k]->GetName() + ": " + expr_chunk.data[k].GetValue(row_idx).ToString();
 	}
 	return key_name;
 }
@@ -1006,7 +951,7 @@ string ART::GenerateErrorKeyName(DataChunk &input, idx_t row) {
 string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, const string &key_name) {
 	switch (verify_type) {
 	case VerifyExistenceType::APPEND: {
-		// APPEND to PK/UNIQUE table, but node/key already exists in PK/UNIQUE table
+		// APPEND to PK/UNIQUE table, but node/key already exists in PK/UNIQUE table.
 		string type = IsPrimary() ? "primary key" : "unique";
 		return StringUtil::Format("Duplicate key \"%s\" violates %s constraint. "
 		                          "If this is an unexpected constraint violation please double "
@@ -1015,12 +960,12 @@ string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, cons
 		                          key_name, type);
 	}
 	case VerifyExistenceType::APPEND_FK: {
-		// APPEND_FK to FK table, node/key does not exist in PK/UNIQUE table
+		// APPEND_FK to FK table, node/key does not exist in PK/UNIQUE table.
 		return StringUtil::Format(
 		    "Violates foreign key constraint because key \"%s\" does not exist in the referenced table", key_name);
 	}
 	case VerifyExistenceType::DELETE_FK: {
-		// DELETE_FK that still exists in a FK table, i.e., not a valid delete
+		// DELETE_FK that still exists in a FK table, i.e., not a valid delete.
 		return StringUtil::Format("Violates foreign key constraint because key \"%s\" is still referenced by a foreign "
 		                          "key in a different table",
 		                          key_name);
@@ -1031,23 +976,19 @@ string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, cons
 }
 
 void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) {
-
-	// don't alter the index during constraint checking
+	// Lock the index during constraint checking.
 	lock_guard<mutex> l(lock);
 
-	// first resolve the expressions for the index
-	DataChunk expression_chunk;
-	expression_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
-	ExecuteExpressions(input, expression_chunk);
+	DataChunk expr_chunk;
+	expr_chunk.Initialize(Allocator::DefaultAllocator(), logical_types);
+	ExecuteExpressions(input, expr_chunk);
 
-	// generate the keys for the given input
 	ArenaAllocator arena_allocator(BufferAllocator::Get(db));
-	vector<ARTKey> keys(expression_chunk.size());
-	GenerateKeys(arena_allocator, expression_chunk, keys);
+	unsafe_vector<ARTKey> keys(expr_chunk.size());
+	GenerateKeys<>(arena_allocator, expr_chunk, keys);
 
-	idx_t found_conflict = DConstants::INVALID_INDEX;
+	auto found_conflict = DConstants::INVALID_INDEX;
 	for (idx_t i = 0; found_conflict == DConstants::INVALID_INDEX && i < input.size(); i++) {
-
 		if (keys[i].Empty()) {
 			if (conflict_manager.AddNull(i)) {
 				found_conflict = i;
@@ -1063,8 +1004,8 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 			continue;
 		}
 
-		// when we find a node, we need to update the 'matches' and 'row_ids'
-		// NOTE: leaves can have more than one row_id, but for UNIQUE/PRIMARY KEY they will only have one
+		// If we find a node, we need to update the 'matches' and 'row_ids'.
+		// We only perform constraint checking on unique indexes, i.e., all leaves are inlined.
 		D_ASSERT(leaf->GetType() == NType::LEAF_INLINED);
 		if (conflict_manager.AddHit(i, leaf->GetRowId())) {
 			found_conflict = i;
@@ -1072,7 +1013,6 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 	}
 
 	conflict_manager.FinishLookup();
-
 	if (found_conflict == DConstants::INVALID_INDEX) {
 		return;
 	}
@@ -1082,93 +1022,178 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 	throw ConstraintException(exception_msg);
 }
 
+string ART::GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index, DataChunk &input) {
+	auto key_name = GenerateErrorKeyName(input, failed_index);
+	auto exception_msg = GenerateConstraintErrorMessage(verify_type, key_name);
+	return exception_msg;
+}
+
 //===--------------------------------------------------------------------===//
-// Helper functions for (de)serialization
+// Storage and Memory
 //===--------------------------------------------------------------------===//
 
-IndexStorageInfo ART::GetStorageInfo(const bool get_buffers) {
+void ART::TransformToDeprecated() {
+	auto idx = Node::GetAllocatorIdx(NType::PREFIX);
+	auto &block_manager = (*allocators)[idx]->block_manager;
+	unsafe_unique_ptr<FixedSizeAllocator> deprecated_allocator;
+
+	if (prefix_count != Prefix::DEPRECATED_COUNT) {
+		auto prefix_size = NumericCast<idx_t>(Prefix::DEPRECATED_COUNT) + NumericCast<idx_t>(Prefix::METADATA_SIZE);
+		deprecated_allocator = make_unsafe_uniq<FixedSizeAllocator>(prefix_size, block_manager);
+	}
+
+	// Transform all leaves, and possibly the prefixes.
+	if (tree.HasMetadata()) {
+		Node::TransformToDeprecated(*this, tree, deprecated_allocator);
+	}
+
+	// Replace the prefix allocator with the deprecated allocator.
+	if (deprecated_allocator) {
+		prefix_count = Prefix::DEPRECATED_COUNT;
+
+		D_ASSERT((*allocators)[idx]->IsEmpty());
+		(*allocators)[idx]->Reset();
+		(*allocators)[idx] = std::move(deprecated_allocator);
+	}
+}
+
+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();
+	}
 
-	// set the name and root node
-	IndexStorageInfo info;
-	info.name = name;
+	IndexStorageInfo info(name);
 	info.root = tree.Get();
+	info.options = options;
 
-	if (!get_buffers) {
-		// store the data on disk as partial blocks and set the block ids
-		WritePartialBlocks();
+	for (auto &allocator : *allocators) {
+		allocator->RemoveEmptyBuffers();
+	}
+
+#ifdef DEBUG
+	if (v1_0_0_storage) {
+		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_7_LEAF)]->IsEmpty());
+		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_15_LEAF)]->IsEmpty());
+		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::NODE_256_LEAF)]->IsEmpty());
+		D_ASSERT((*allocators)[Node::GetAllocatorIdx(NType::PREFIX)]->GetSegmentSize() ==
+		         Prefix::DEPRECATED_COUNT + Prefix::METADATA_SIZE);
+	}
+#endif
+
+	auto allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
+	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 (const auto &allocator : *allocators) {
-			info.buffers.push_back(allocator->InitSerializationToWAL());
+		// 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 (const auto &allocator : *allocators) {
-		info.allocator_infos.push_back(allocator->GetInfo());
+	for (idx_t i = 0; i < allocator_count; i++) {
+		info.allocator_infos.push_back((*allocators)[i]->GetInfo());
 	}
-
 	return info;
 }
 
-void ART::WritePartialBlocks() {
-
-	// use the partial block manager to serialize all allocator data
+void ART::WritePartialBlocks(const bool v1_0_0_storage) {
 	auto &block_manager = table_io_manager.GetIndexBlockManager();
 	PartialBlockManager partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT);
 
-	for (auto &allocator : *allocators) {
-		allocator->SerializeBuffers(partial_block_manager);
+	idx_t allocator_count = v1_0_0_storage ? DEPRECATED_ALLOCATOR_COUNT : ALLOCATOR_COUNT;
+	for (idx_t i = 0; i < allocator_count; i++) {
+		(*allocators)[i]->SerializeBuffers(partial_block_manager);
 	}
 	partial_block_manager.FlushPartialBlocks();
 }
 
 void ART::InitAllocators(const IndexStorageInfo &info) {
-
-	// set the root node
-	tree.Set(info.root);
-
-	// initialize the allocators
-	D_ASSERT(info.allocator_infos.size() == ALLOCATOR_COUNT);
 	for (idx_t i = 0; i < info.allocator_infos.size(); i++) {
 		(*allocators)[i]->Init(info.allocator_infos[i]);
 	}
 }
 
 void ART::Deserialize(const BlockPointer &pointer) {
-
 	D_ASSERT(pointer.IsValid());
+
 	auto &metadata_manager = table_io_manager.GetMetadataManager();
 	MetadataReader reader(metadata_manager, pointer);
 	tree = reader.Read<Node>();
 
-	for (idx_t i = 0; i < ALLOCATOR_COUNT; i++) {
+	for (idx_t i = 0; i < DEPRECATED_ALLOCATOR_COUNT; i++) {
 		(*allocators)[i]->Deserialize(metadata_manager, reader.Read<BlockPointer>());
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Vacuum
-//===--------------------------------------------------------------------===//
+void ART::SetPrefixCount(const IndexStorageInfo &info) {
+	auto numeric_max = NumericLimits<uint8_t>().Maximum();
+	auto max_aligned = AlignValueFloor<uint8_t>(numeric_max - Prefix::METADATA_SIZE);
+
+	if (info.IsValid() && info.root_block_ptr.IsValid()) {
+		prefix_count = Prefix::DEPRECATED_COUNT;
+		return;
+	}
 
-void ART::InitializeVacuum(ARTFlags &flags) {
-	flags.vacuum_flags.reserve(flags.vacuum_flags.size() + allocators->size());
+	if (info.IsValid()) {
+		auto serialized_count = info.allocator_infos[0].segment_size - Prefix::METADATA_SIZE;
+		prefix_count = NumericCast<uint8_t>(serialized_count);
+		return;
+	}
+
+	if (!IsUnique()) {
+		prefix_count = Prefix::ROW_ID_COUNT;
+		return;
+	}
+
+	idx_t compound_size = 0;
+	for (const auto &type : types) {
+		compound_size += GetTypeIdSize(type);
+	}
+
+	auto aligned = AlignValue(compound_size) - 1;
+	if (aligned > NumericCast<idx_t>(max_aligned)) {
+		prefix_count = max_aligned;
+		return;
+	}
+
+	prefix_count = NumericCast<uint8_t>(aligned);
+}
+
+idx_t ART::GetInMemorySize(IndexLock &index_lock) {
+	D_ASSERT(owns_data);
+
+	idx_t in_memory_size = 0;
 	for (auto &allocator : *allocators) {
-		flags.vacuum_flags.push_back(allocator->InitializeVacuum());
+		in_memory_size += allocator->GetInMemorySize();
 	}
+	return in_memory_size;
 }
 
-void ART::FinalizeVacuum(const ARTFlags &flags) {
+//===--------------------------------------------------------------------===//
+// Vacuum
+//===--------------------------------------------------------------------===//
 
+void ART::InitializeVacuum(unordered_set<uint8_t> &indexes) {
 	for (idx_t i = 0; i < allocators->size(); i++) {
-		if (flags.vacuum_flags[i]) {
-			(*allocators)[i]->FinalizeVacuum();
+		if ((*allocators)[i]->InitializeVacuum()) {
+			indexes.insert(NumericCast<uint8_t>(i));
 		}
 	}
 }
 
-void ART::Vacuum(IndexLock &state) {
+void ART::FinalizeVacuum(const unordered_set<uint8_t> &indexes) {
+	for (const auto &idx : indexes) {
+		(*allocators)[idx]->FinalizeVacuum();
+	}
+}
 
+void ART::Vacuum(IndexLock &state) {
 	D_ASSERT(owns_data);
 
 	if (!tree.HasMetadata()) {
@@ -1178,60 +1203,34 @@ void ART::Vacuum(IndexLock &state) {
 		return;
 	}
 
-	// holds true, if an allocator needs a vacuum, and false otherwise
-	ARTFlags flags;
-	InitializeVacuum(flags);
+	// True, if an allocator needs a vacuum, false otherwise.
+	unordered_set<uint8_t> indexes;
+	InitializeVacuum(indexes);
 
-	// skip vacuum if no allocators require it
-	auto perform_vacuum = false;
-	for (const auto &vacuum_flag : flags.vacuum_flags) {
-		if (vacuum_flag) {
-			perform_vacuum = true;
-			break;
-		}
-	}
-	if (!perform_vacuum) {
+	// Skip vacuum, if no allocators require it.
+	if (indexes.empty()) {
 		return;
 	}
 
-	// traverse the allocated memory of the tree to perform a vacuum
-	tree.Vacuum(*this, flags);
-
-	// finalize the vacuum operation
-	FinalizeVacuum(flags);
-}
+	// Traverse the allocated memory of the tree to perform a vacuum.
+	tree.Vacuum(*this, indexes);
 
-//===--------------------------------------------------------------------===//
-// Size
-//===--------------------------------------------------------------------===//
-
-idx_t ART::GetInMemorySize(IndexLock &index_lock) {
-
-	D_ASSERT(owns_data);
-
-	idx_t in_memory_size = 0;
-	for (auto &allocator : *allocators) {
-		in_memory_size += allocator->GetInMemorySize();
-	}
-	return in_memory_size;
+	// Finalize the vacuum operation.
+	FinalizeVacuum(indexes);
 }
 
 //===--------------------------------------------------------------------===//
 // Merging
 //===--------------------------------------------------------------------===//
 
-void ART::InitializeMerge(ARTFlags &flags) {
-
+void ART::InitializeMerge(unsafe_vector<idx_t> &upper_bounds) {
 	D_ASSERT(owns_data);
-
-	flags.merge_buffer_counts.reserve(allocators->size());
 	for (auto &allocator : *allocators) {
-		flags.merge_buffer_counts.emplace_back(allocator->GetUpperBoundBufferId());
+		upper_bounds.emplace_back(allocator->GetUpperBoundBufferId());
 	}
 }
 
 bool ART::MergeIndexes(IndexLock &state, BoundIndex &other_index) {
-
 	auto &other_art = other_index.Cast<ART>();
 	if (!other_art.tree.HasMetadata()) {
 		return true;
@@ -1239,33 +1238,31 @@ bool ART::MergeIndexes(IndexLock &state, BoundIndex &other_index) {
 
 	if (other_art.owns_data) {
 		if (tree.HasMetadata()) {
-			//  fully deserialize other_index, and traverse it to increment its buffer IDs
-			ARTFlags flags;
-			InitializeMerge(flags);
-			other_art.tree.InitializeMerge(other_art, flags);
+			// Fully deserialize other_index, and traverse it to increment its buffer IDs.
+			unsafe_vector<idx_t> upper_bounds;
+			InitializeMerge(upper_bounds);
+			other_art.tree.InitMerge(other_art, upper_bounds);
 		}
 
-		// merge the node storage
+		// Merge the node storage.
 		for (idx_t i = 0; i < allocators->size(); i++) {
 			(*allocators)[i]->Merge(*(*other_art.allocators)[i]);
 		}
 	}
 
-	// merge the ARTs
-	if (!tree.Merge(*this, other_art.tree)) {
+	// Merge the ARTs.
+	D_ASSERT(tree.GetGateStatus() == other_art.tree.GetGateStatus());
+	if (!tree.Merge(*this, other_art.tree, tree.GetGateStatus())) {
 		return false;
 	}
 	return true;
 }
 
 //===--------------------------------------------------------------------===//
-// Utility
+// Verification
 //===--------------------------------------------------------------------===//
 
 string ART::VerifyAndToString(IndexLock &state, const bool only_verify) {
-	// FIXME: this can be improved by counting the allocations of each node type,
-	// FIXME: and by asserting that each fixed-size allocator lists an equal number of
-	// FIXME: allocations of that type
 	return VerifyAndToStringInternal(only_verify);
 }
 
@@ -1276,10 +1273,26 @@ string ART::VerifyAndToStringInternal(const bool only_verify) {
 	return "[empty]";
 }
 
-string ART::GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index, DataChunk &input) {
-	auto key_name = GenerateErrorKeyName(input, failed_index);
-	auto exception_msg = GenerateConstraintErrorMessage(verify_type, key_name);
-	return exception_msg;
+void ART::VerifyAllocations(IndexLock &state) {
+	return VerifyAllocationsInternal();
+}
+
+void ART::VerifyAllocationsInternal() {
+#ifdef DEBUG
+	unordered_map<uint8_t, idx_t> node_counts;
+	for (idx_t i = 0; i < allocators->size(); i++) {
+		node_counts[NumericCast<uint8_t>(i)] = 0;
+	}
+
+	if (tree.HasMetadata()) {
+		tree.VerifyAllocations(*this, node_counts);
+	}
+
+	for (idx_t i = 0; i < allocators->size(); i++) {
+		auto segment_count = (*allocators)[i]->GetSegmentCount();
+		D_ASSERT(segment_count == node_counts[NumericCast<uint8_t>(i)]);
+	}
+#endif
 }
 
 constexpr const char *ART::TYPE_NAME;