duckdb 0.7.2-dev2552.0 → 0.7.2-dev2675.0

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

@@ -1,97 +1,22 @@
 #include "duckdb/execution/index/art/swizzleable_pointer.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/storage/meta_block_reader.hpp"
 
 namespace duckdb {
-SwizzleablePointer::~SwizzleablePointer() {
-	if (pointer) {
-		if (!IsSwizzled()) {
-			Node::Delete((Node *)pointer);
-		}
-	}
-}
 
-SwizzleablePointer::SwizzleablePointer(duckdb::MetaBlockReader &reader) {
-	idx_t block_id = reader.Read<block_id_t>();
-	uint32_t offset = reader.Read<uint32_t>();
-	if (block_id == DConstants::INVALID_INDEX || offset == (uint32_t)DConstants::INVALID_INDEX) {
-		pointer = 0;
-		return;
-	}
-	idx_t pointer_size = sizeof(pointer) * 8;
-	pointer = block_id;
-	// This assumes high 32 bits of pointer are zero.
-	pointer = pointer << (pointer_size / 2);
-	D_ASSERT((pointer >> (pointer_size / 2)) == block_id);
-	pointer += offset;
-	// Set the left most bit to indicate this is a swizzled pointer and send it back to the mother-ship
-	uint64_t mask = 1;
-	mask = mask << (pointer_size - 1);
-	// This assumes the 33rd most significant bit of the block_id is zero.
-	pointer |= mask;
-}
-
-SwizzleablePointer &SwizzleablePointer::operator=(const Node *ptr) {
-	// If the object already has a non-swizzled pointer, this will leak memory.
-	//
-	// TODO: If enabled, this assert will fire, indicating a possible leak. If an exception
-	// is thrown here, it will cause a double-free. There is some work to do to make all this safer.
-	// D_ASSERT(empty() || IsSwizzled());
-	if (sizeof(ptr) == 4) {
-		pointer = (uint32_t)(size_t)ptr;
-	} else {
-		pointer = (uint64_t)ptr;
-	}
-	return *this;
-}
-
-bool operator!=(const SwizzleablePointer &s_ptr, const uint64_t &ptr) {
-	return (s_ptr.pointer != ptr);
-}
+SwizzleablePointer::SwizzleablePointer(MetaBlockReader &reader) {
 
-BlockPointer SwizzleablePointer::GetSwizzledBlockInfo() {
-	D_ASSERT(IsSwizzled());
-	idx_t pointer_size = sizeof(pointer) * 8;
-	// This is destructive. Pointer will be invalid after this operation.
-	// That's okay because this is only ever called from Unswizzle.
-	pointer = pointer & ~(1ULL << (pointer_size - 1));
-	uint32_t block_id = pointer >> (pointer_size / 2);
-	uint32_t offset = pointer & 0xffffffff;
-	return {block_id, offset};
-}
-
-bool SwizzleablePointer::IsSwizzled() {
-	idx_t pointer_size = sizeof(pointer) * 8;
-	return (pointer >> (pointer_size - 1)) & 1;
-}
-
-void SwizzleablePointer::Reset() {
-	if (pointer) {
-		if (!IsSwizzled()) {
-			Node::Delete((Node *)pointer);
-		}
-	}
-	*this = nullptr;
-}
+	idx_t block_id = reader.Read<block_id_t>();
+	offset = reader.Read<uint32_t>();
+	type = 0;
 
-Node *SwizzleablePointer::Unswizzle(ART &art) {
-	if (IsSwizzled()) {
-		// This means our pointer is not yet in memory, gotta deserialize this
-		// first we unset the bae
-		auto block_info = GetSwizzledBlockInfo();
-		*this = Node::Deserialize(art, block_info.block_id, block_info.offset);
-		art.Verify();
+	if (block_id == DConstants::INVALID_INDEX) {
+		swizzle_flag = 0;
+		return;
 	}
-	return (Node *)pointer;
-}
 
-BlockPointer SwizzleablePointer::Serialize(ART &art, duckdb::MetaBlockWriter &writer) {
-	if (pointer) {
-		Unswizzle(art);
-		return ((Node *)pointer)->Serialize(art, writer);
-	} else {
-		return {(block_id_t)DConstants::INVALID_INDEX, (uint32_t)DConstants::INVALID_INDEX};
-	}
+	buffer_id = (uint32_t)block_id;
+	swizzle_flag = 1;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
 
 namespace duckdb {
 
@@ -48,7 +49,7 @@ public:
 	ExpressionExecutor probe_executor;
 
 	ArenaAllocator arena_allocator;
-	vector<Key> keys;
+	vector<ARTKey> keys;
 	unique_ptr<ColumnFetchState> fetch_state;
 
 public:

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -268,8 +268,8 @@ void BaseCSVReader::AddValue(string_t str_val, idx_t &column, vector<idx_t> &esc
 	idx_t row_entry = parse_chunk.size();
 
 	// test against null string, but only if the value was not quoted
-	if ((!has_quotes || return_types[column].id() != LogicalTypeId::VARCHAR) && !options.force_not_null[column] &&
-	    Equals::Operation(str_val, string_t(options.null_str))) {
+	if ((!(has_quotes && !options.allow_quoted_nulls) || return_types[column].id() != LogicalTypeId::VARCHAR) &&
+	    !options.force_not_null[column] && Equals::Operation(str_val, string_t(options.null_str))) {
 		FlatVector::SetNull(parse_chunk.data[column], row_entry, true);
 	} else {
 		auto &v = parse_chunk.data[column];

package/src/duckdb/src/execution/operator/persistent/csv_reader_options.cpp

@@ -175,6 +175,8 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 		}
 	} else if (loption == "null_padding") {
 		null_padding = ParseBoolean(value, loption);
+	} else if (loption == "allow_quoted_nulls") {
+		allow_quoted_nulls = ParseBoolean(value, loption);
 	} else {
 		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
 	}

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
 
 namespace duckdb {
 
@@ -39,7 +40,7 @@ public:
 
 	unique_ptr<Index> local_index;
 	ArenaAllocator arena_allocator;
-	vector<Key> keys;
+	vector<ARTKey> keys;
 	DataChunk key_chunk;
 	vector<column_t> key_column_ids;
 };
@@ -52,7 +53,7 @@ unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContex
 	case IndexType::ART: {
 		auto &storage = table.GetStorage();
 		state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                     info->constraint_type, storage.db, true);
+		                                     info->constraint_type, storage.db);
 		break;
 	}
 	default:
@@ -69,13 +70,13 @@ unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionConte
 	case IndexType::ART: {
 		auto &storage = table.GetStorage();
 		state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                    info->constraint_type, storage.db, false);
+		                                    info->constraint_type, storage.db);
 		break;
 	}
 	default:
 		throw InternalException("Unimplemented index type");
 	}
-	state->keys = vector<Key>(STANDARD_VECTOR_SIZE);
+	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
 	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
 
 	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
@@ -97,9 +98,8 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkSt
 	ART::GenerateKeys(lstate.arena_allocator, lstate.key_chunk, lstate.keys);
 
 	auto &storage = table.GetStorage();
-	auto art =
-	    make_uniq<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
-	                   lstate.local_index->unbound_expressions, lstate.local_index->constraint_type, storage.db, false);
+	auto art = make_uniq<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
+	                          lstate.local_index->unbound_expressions, lstate.local_index->constraint_type, storage.db);
 	if (!art->ConstructFromSorted(lstate.key_chunk.size(), lstate.keys, row_identifiers)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
@@ -134,11 +134,6 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
 	}
 
-	state.global_index->Verify();
-	if (state.global_index->track_memory) {
-		state.global_index->buffer_manager.IncreaseUsedMemory(state.global_index->memory_size);
-	}
-
 	auto &schema = table.schema;
 	auto index_entry = schema.CreateIndex(context, *info, table).get();
 	if (!index_entry) {
@@ -153,6 +148,10 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
+	// vacuum excess memory
+	state.global_index->Vacuum();
+
+	// add index to storage
 	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/function/table/read_csv.cpp

@@ -27,7 +27,7 @@ unique_ptr<CSVFileHandle> ReadCSV::OpenCSV(const string &file_path, FileCompress
 	if (file_handle->CanSeek()) {
 		file_handle->Reset();
 	}
-	return make_uniq<CSVFileHandle>(std::move(file_handle));
+	return make_uniq<CSVFileHandle>(std::move(file_handle), false);
 }
 
 void ReadCSVData::FinalizeRead(ClientContext &context) {
@@ -259,6 +259,7 @@ public:
 	                       idx_t rows_to_skip, bool force_parallelism_p, vector<column_t> column_ids_p)
 	    : file_handle(std::move(file_handle_p)), system_threads(system_threads_p), buffer_size(buffer_size_p),
 	      force_parallelism(force_parallelism_p), column_ids(std::move(column_ids_p)) {
+		file_handle->DisableReset();
 		current_file_path = files_path_p[0];
 		estimated_linenr = rows_to_skip;
 		file_size = file_handle->FileSize();
@@ -861,6 +862,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["allow_quoted_nulls"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["column_types"] = LogicalType::ANY;
 	table_function.named_parameters["dtypes"] = LogicalType::ANY;
 	table_function.named_parameters["types"] = LogicalType::ANY;
@@ -920,6 +922,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteString(null_str);
 	writer.WriteField<FileCompressionType>(compression);
 	writer.WriteField<NewLineIdentifier>(new_line);
+	writer.WriteField<bool>(allow_quoted_nulls);
 	// read options
 	writer.WriteField<idx_t>(skip_rows);
 	writer.WriteField<bool>(skip_rows_set);
@@ -954,6 +957,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	null_str = reader.ReadRequired<string>();
 	compression = reader.ReadRequired<FileCompressionType>();
 	new_line = reader.ReadRequired<NewLineIdentifier>();
+	allow_quoted_nulls = reader.ReadRequired<bool>();
 	// read options
 	skip_rows = reader.ReadRequired<idx_t>();
 	skip_rows_set = reader.ReadRequired<bool>();

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2552"
+#define DUCKDB_VERSION "0.7.2-dev2675"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "98590facb8"
+#define DUCKDB_SOURCE_ID "688b2f1f8c"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/queue.hpp

@@ -12,4 +12,4 @@
 
 namespace duckdb {
 using std::queue;
-}
+} // namespace duckdb

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

@@ -8,56 +8,54 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/iterator.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-#include "duckdb/execution/index/art/node.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/node48.hpp"
-#include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/index.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
 
 namespace duckdb {
 
-class ConflictManager;
-struct ARTIndexScanState;
-
+// classes
 enum class VerifyExistenceType : uint8_t {
 	APPEND = 0,    // appends to a table
 	APPEND_FK = 1, // appends to a table that has a foreign key
 	DELETE_FK = 2  // delete from a table that has a foreign key
 };
+class ConflictManager;
+class Node;
+class ARTKey;
+class FixedSizeAllocator;
+
+// structs
+struct ARTIndexScanState;
+struct ARTFlags {
+	vector<bool> vacuum_flags;
+	vector<idx_t> merge_buffer_counts;
+};
 
 class ART : public Index {
 public:
-	//! Constructs an ART containing the bound expressions, which are resolved during index construction
+	//! Constructs an ART
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-	    const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-	    AttachedDatabase &db, bool track_memory, idx_t block_id = DConstants::INVALID_INDEX,
-	    idx_t block_offset = DConstants::INVALID_INDEX);
+	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
+	    AttachedDatabase &db, const idx_t block_id = DConstants::INVALID_INDEX,
+	    const idx_t block_offset = DConstants::INVALID_INDEX);
 	~ART() override;
 
 	//! Root of the tree
-	Node *tree;
+	unique_ptr<Node> tree;
+	//! Fixed-size allocators holding the ART nodes
+	vector<unique_ptr<FixedSizeAllocator>> allocators;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
-	                                                         ExpressionType expression_type) override;
+	                                                         const ExpressionType expression_type) override;
 	//! Initialize a two predicate scan on the index with the given expression and column IDs
-	unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
-	                                                       ExpressionType low_expression_type, const Value &high_value,
-	                                                       ExpressionType high_expression_type) override;
+	unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction, const Value &low_value,
+	                                                       const ExpressionType low_expression_type,
+	                                                       const Value &high_value,
+	                                                       const ExpressionType high_expression_type) override;
 	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
 	//! and false otherwise
-	bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
+	bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, const idx_t max_count,
 	          vector<row_t> &result_ids) override;
 
 	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
@@ -72,22 +70,25 @@ public:
 	PreservedError Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
 
 	//! Construct an ART from a vector of sorted keys
-	bool ConstructFromSorted(idx_t count, vector<Key> &keys, Vector &row_identifiers);
+	bool ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_identifiers);
 
 	//! Search equal values and fetches the row IDs
-	bool SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids);
+	bool SearchEqual(ARTKey &key, idx_t max_count, vector<row_t> &result_ids);
 	//! Search equal values used for joins that do not need to fetch data
-	void SearchEqualJoinNoFetch(Key &key, idx_t &result_size);
+	void SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size);
 
 	//! Serializes the index and returns the pair of block_id offset positions
-	BlockPointer Serialize(duckdb::MetaBlockWriter &writer) override;
+	BlockPointer Serialize(MetaBlockWriter &writer) override;
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
 	bool MergeIndexes(IndexLock &state, Index &other_index) override;
 
+	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
+	void Vacuum(IndexLock &state) override;
+
 	//! Generate ART keys for an input chunk
-	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys);
+	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<ARTKey> &keys);
 
 	//! Generate a string containing all the expressions and their respective values that violate a constraint
 	string GenerateErrorKeyName(DataChunk &input, idx_t row);
@@ -96,31 +97,38 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
-	//! Returns the string representation of an ART
+	//! Returns the string representation of the ART
 	string ToString() override;
-	//! Verifies that the in-memory size value of the index matches its actual size
-	void Verify() override;
-	//! Increases the memory size by the difference between the old size and the current size
-	//! and performs verifications
-	void IncreaseAndVerifyMemorySize(idx_t old_memory_size) override;
 
 private:
 	//! Insert a row ID into a leaf
-	bool InsertToLeaf(Leaf &leaf, row_t row_id);
+	bool InsertToLeaf(Node &leaf_node, const row_t &row_id);
 	//! Insert a key into the tree
-	bool Insert(Node *&node, Key &key, idx_t depth, row_t row_id);
+	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
-	void Erase(Node *&node, Key &key, idx_t depth, row_t row_id);
+	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Find the node with a matching key, or return nullptr if not found
-	Leaf *Lookup(Node *node, Key &key, idx_t depth);
+	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 	//! Returns all row IDs belonging to a key greater (or equal) than the search key
-	bool SearchGreater(ARTIndexScanState *state, Key &key, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
+	bool SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, idx_t max_count,
+	                   vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key less (or equal) than the upper_bound
-	bool SearchLess(ARTIndexScanState *state, Key &upper_bound, bool inclusive, idx_t max_count,
+	bool SearchLess(ARTIndexScanState *state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
 	                vector<row_t> &result_ids);
 	//! Returns all row IDs belonging to a key within the range of lower_bound and upper_bound
-	bool SearchCloseRange(ARTIndexScanState *state, Key &lower_bound, Key &upper_bound, bool left_inclusive,
+	bool SearchCloseRange(ARTIndexScanState *state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
 	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
+
+	//! Initializes a merge operation by returning a set containing the buffer count of each fixed-size allocator
+	void InitializeMerge(ARTFlags &flags);
+
+	//! Initializes a vacuum operation by calling the initialize operation of the respective
+	//! node allocator, and returns a vector containing either true, if the allocator at
+	//! the respective position qualifies, or false, if not
+	void InitializeVacuum(ARTFlags &flags);
+	//! Finalizes a vacuum operation by calling the finalize operation of all qualifying
+	//! fixed size allocators
+	void FinalizeVacuum(const ARTFlags &flags);
 };
 
 } // namespace duckdb

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

@@ -17,36 +17,37 @@
 
 namespace duckdb {
 
-class Key {
+class ARTKey {
 public:
-	Key();
-	Key(data_ptr_t data, idx_t len);
-	Key(ArenaAllocator &allocator, idx_t len);
+	ARTKey();
+	ARTKey(const data_ptr_t &data, const uint32_t &len);
+	ARTKey(ArenaAllocator &allocator, const uint32_t &len);
 
-	idx_t len;
+	uint32_t len;
 	data_ptr_t data;
 
 public:
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, T element) {
-		auto data = Key::CreateData<T>(allocator, element);
-		return Key(data, sizeof(element));
+	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, T element) {
+		auto data = ARTKey::CreateData<T>(allocator, element);
+		return ARTKey(data, sizeof(element));
 	}
 
 	template <class T>
-	static inline Key CreateKey(ArenaAllocator &allocator, const LogicalType &type, const Value &element) {
-		return CreateKey(allocator, type, element.GetValueUnsafe<T>());
+	static inline ARTKey CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const Value &element) {
+		return CreateARTKey(allocator, type, element.GetValueUnsafe<T>());
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, T element) {
-		key.data = Key::CreateData<T>(allocator, element);
+	static inline void CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, T element) {
+		key.data = ARTKey::CreateData<T>(allocator, element);
 		key.len = sizeof(element);
 	}
 
 	template <class T>
-	static inline void CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, const Value element) {
-		key.data = Key::CreateData<T>(allocator, element.GetValueUnsafe<T>());
+	static inline void CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key,
+	                                const Value element) {
+		key.data = ARTKey::CreateData<T>(allocator, element.GetValueUnsafe<T>());
 		key.len = sizeof(element);
 	}
 
@@ -57,14 +58,18 @@ public:
 	const data_t &operator[](size_t i) const {
 		return data[i];
 	}
-	bool operator>(const Key &k) const;
-	bool operator<(const Key &k) const;
-	bool operator>=(const Key &k) const;
-	bool operator==(const Key &k) const;
+	bool operator>(const ARTKey &k) const;
+	bool operator<(const ARTKey &k) const;
+	bool operator>=(const ARTKey &k) const;
+	bool operator==(const ARTKey &k) const;
 
-	bool ByteMatches(Key &other, idx_t &depth);
-	bool Empty();
-	void ConcatenateKey(ArenaAllocator &allocator, Key &concat_key);
+	inline bool ByteMatches(const ARTKey &other, const uint32_t &depth) const {
+		return data[depth] == other[depth];
+	}
+	inline bool Empty() const {
+		return len == 0;
+	}
+	void ConcatenateARTKey(ArenaAllocator &allocator, ARTKey &concat_key);
 
 private:
 	template <class T>
@@ -76,9 +81,9 @@ private:
 };
 
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, string_t value);
+ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, string_t value);
 template <>
-Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, const char *value);
+ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, const char *value);
 template <>
-void Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, string_t value);
+void ARTKey::CreateARTKey(ArenaAllocator &allocator, const LogicalType &type, ARTKey &key, string_t value);
 } // namespace duckdb

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

@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/fixed_size_allocator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/assert.hpp"
+#include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
+
+namespace duckdb {
+
+struct BufferEntry {
+	BufferEntry(const data_ptr_t &ptr, const idx_t &allocation_count) : ptr(ptr), allocation_count(allocation_count) {
+	}
+	data_ptr_t ptr;
+	idx_t allocation_count;
+};
+
+//! The FixedSizeAllocator provides pointers to fixed-size sections of pre-allocated memory buffers.
+//! The pointers are SwizzleablePointers, and the leftmost byte (swizzle flag and type) must always be zero.
+class FixedSizeAllocator {
+public:
+	//! Fixed size of the buffers
+	static constexpr idx_t BUFFER_ALLOC_SIZE = Storage::BLOCK_ALLOC_SIZE;
+	//! We can vacuum 10% or more of the total memory usage of the allocator
+	static constexpr uint8_t VACUUM_THRESHOLD = 10;
+
+	//! Constants for fast offset calculations in the bitmask
+	static constexpr idx_t BASE[] = {0x00000000FFFFFFFF, 0x0000FFFF, 0x00FF, 0x0F, 0x3, 0x1};
+	static constexpr uint8_t SHIFT[] = {32, 16, 8, 4, 2, 1};
+
+public:
+	explicit FixedSizeAllocator(const idx_t allocation_size, Allocator &allocator);
+	~FixedSizeAllocator();
+
+	//! Allocation size of one element in a buffer
+	idx_t allocation_size;
+	//! Total number of allocations
+	idx_t total_allocations;
+	//! Number of validity_t values in the bitmask
+	idx_t bitmask_count;
+	//! First starting byte of the payload
+	idx_t allocation_offset;
+	//! Number of possible allocations per buffer
+	idx_t allocations_per_buffer;
+
+	//! Buffers containing the data
+	vector<BufferEntry> buffers;
+	//! Buffers with free space
+	unordered_set<idx_t> buffers_with_free_space;
+
+	//! Minimum buffer ID of buffers that can be vacuumed
+	idx_t min_vacuum_buffer_id;
+
+	//! Buffer manager of the database instance
+	Allocator &allocator;
+
+public:
+	//! Get a new pointer to data, might cause a new buffer allocation
+	SwizzleablePointer New();
+	//! Free the data of the pointer
+	void Free(const SwizzleablePointer ptr);
+	//! Get the data of the pointer
+	template <class T>
+	inline T *Get(const SwizzleablePointer ptr) const {
+		return (T *)Get(ptr);
+	}
+
+	//! Resets the allocator, which e.g. becomes necessary during DELETE FROM table
+	void Reset();
+
+	//! Returns the allocated memory size in bytes
+	inline idx_t GetMemoryUsage() const {
+		return buffers.size() * BUFFER_ALLOC_SIZE;
+	}
+
+	//! Merge another FixedSizeAllocator with this allocator. Both must have the same allocation size
+	void Merge(FixedSizeAllocator &other);
+
+	//! Initialize a vacuum operation, and return true, if the allocator needs a vacuum
+	bool InitializeVacuum();
+	//! Finalize a vacuum operation by freeing all buffers exceeding the min_vacuum_buffer_id
+	void FinalizeVacuum();
+	//! Returns true, if a pointer qualifies for a vacuum operation, and false otherwise
+	inline bool NeedsVacuum(const SwizzleablePointer ptr) const {
+		if (ptr.buffer_id >= min_vacuum_buffer_id) {
+			return true;
+		}
+		return false;
+	}
+	//! Vacuums a pointer
+	SwizzleablePointer VacuumPointer(const SwizzleablePointer ptr);
+
+private:
+	//! Returns the data_ptr_t of a pointer
+	inline data_ptr_t Get(const SwizzleablePointer ptr) const {
+		D_ASSERT(ptr.buffer_id < buffers.size());
+		D_ASSERT(ptr.offset < allocations_per_buffer);
+		return buffers[ptr.buffer_id].ptr + ptr.offset * allocation_size + allocation_offset;
+	}
+	//! Returns the first free offset in a bitmask
+	uint32_t GetOffset(ValidityMask &mask, const idx_t allocation_count);
+};
+
+} // namespace duckdb