duckdb 0.8.2-dev4025.0 → 0.8.2-dev4142.0

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

@@ -0,0 +1,345 @@
+#include "duckdb/execution/index/fixed_size_allocator.hpp"
+
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+
+namespace duckdb {
+
+constexpr idx_t FixedSizeAllocator::BASE[];
+constexpr uint8_t FixedSizeAllocator::SHIFT[];
+
+FixedSizeAllocator::FixedSizeAllocator(const idx_t segment_size, BlockManager &block_manager)
+    : block_manager(block_manager), buffer_manager(block_manager.buffer_manager),
+      metadata_manager(block_manager.GetMetadataManager()), segment_size(segment_size), total_segment_count(0) {
+
+	if (segment_size > Storage::BLOCK_SIZE - sizeof(validity_t)) {
+		throw InternalException("The maximum segment size of fixed-size allocators is " +
+		                        to_string(Storage::BLOCK_SIZE - sizeof(validity_t)));
+	}
+
+	// calculate how many segments fit into one buffer (available_segments_per_buffer)
+
+	idx_t bits_per_value = sizeof(validity_t) * 8;
+	idx_t byte_count = 0;
+
+	bitmask_count = 0;
+	available_segments_per_buffer = 0;
+
+	while (byte_count < Storage::BLOCK_SIZE) {
+		if (!bitmask_count || (bitmask_count * bits_per_value) % available_segments_per_buffer == 0) {
+			// we need to add another validity_t value to the bitmask, to allow storing another
+			// bits_per_value segments on a buffer
+			bitmask_count++;
+			byte_count += sizeof(validity_t);
+		}
+
+		auto remaining_bytes = Storage::BLOCK_SIZE - byte_count;
+		auto remaining_segments = MinValue(remaining_bytes / segment_size, bits_per_value);
+
+		if (remaining_segments == 0) {
+			break;
+		}
+
+		available_segments_per_buffer += remaining_segments;
+		byte_count += remaining_segments * segment_size;
+	}
+
+	bitmask_offset = bitmask_count * sizeof(validity_t);
+}
+
+IndexPointer FixedSizeAllocator::New() {
+
+	// no more segments available
+	if (buffers_with_free_space.empty()) {
+
+		// add a new buffer
+		auto buffer_id = GetAvailableBufferId();
+		FixedSizeBuffer new_buffer(block_manager);
+		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
+		buffers_with_free_space.insert(buffer_id);
+
+		// set the bitmask
+		D_ASSERT(buffers.find(buffer_id) != buffers.end());
+		auto &buffer = buffers.find(buffer_id)->second;
+		ValidityMask mask(reinterpret_cast<validity_t *>(buffer.Get()));
+		mask.SetAllValid(available_segments_per_buffer);
+	}
+
+	// return a pointer
+	D_ASSERT(!buffers_with_free_space.empty());
+	auto buffer_id = uint32_t(*buffers_with_free_space.begin());
+
+	D_ASSERT(buffers.find(buffer_id) != buffers.end());
+	auto &buffer = buffers.find(buffer_id)->second;
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer.Get());
+	ValidityMask mask(bitmask_ptr);
+	auto offset = GetOffset(mask, buffer.segment_count);
+
+	buffer.segment_count++;
+	total_segment_count++;
+	if (buffer.segment_count == available_segments_per_buffer) {
+		buffers_with_free_space.erase(buffer_id);
+	}
+
+	return IndexPointer(buffer_id, offset);
+}
+
+void FixedSizeAllocator::Free(const IndexPointer ptr) {
+
+	auto buffer_id = ptr.GetBufferId();
+	auto offset = ptr.GetOffset();
+
+	D_ASSERT(buffers.find(buffer_id) != buffers.end());
+	auto &buffer = buffers.find(buffer_id)->second;
+
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffer.Get());
+	ValidityMask mask(bitmask_ptr);
+	D_ASSERT(!mask.RowIsValid(offset));
+	mask.SetValid(offset);
+	buffers_with_free_space.insert(buffer_id);
+
+	D_ASSERT(total_segment_count > 0);
+	D_ASSERT(buffer.segment_count > 0);
+
+	buffer.segment_count--;
+	total_segment_count--;
+}
+
+void FixedSizeAllocator::Reset() {
+	for (auto &buffer : buffers) {
+		buffer.second.Destroy();
+	}
+	buffers.clear();
+	buffers_with_free_space.clear();
+	total_segment_count = 0;
+}
+
+idx_t FixedSizeAllocator::GetMemoryUsage() const {
+	idx_t memory_usage = 0;
+	for (auto &buffer : buffers) {
+		if (buffer.second.InMemory()) {
+			memory_usage += Storage::BLOCK_SIZE;
+		}
+	}
+	return memory_usage;
+}
+
+void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
+
+	D_ASSERT(segment_size == other.segment_size);
+
+	// remember the buffer count and merge the buffers
+	idx_t upper_bound_id = GetUpperBoundBufferId();
+	for (auto &buffer : other.buffers) {
+		buffers.insert(make_pair(buffer.first + upper_bound_id, std::move(buffer.second)));
+	}
+	other.buffers.clear();
+
+	// merge the buffers with free spaces
+	for (auto &buffer_id : other.buffers_with_free_space) {
+		buffers_with_free_space.insert(buffer_id + upper_bound_id);
+	}
+	other.buffers_with_free_space.clear();
+
+	// add the total allocations
+	total_segment_count += other.total_segment_count;
+}
+
+bool FixedSizeAllocator::InitializeVacuum() {
+
+	// NOTE: we do not vacuum buffers that are not in memory. We might consider changing this
+	// in the future, although buffers on disk should almost never be eligible for a vacuum
+
+	if (total_segment_count == 0) {
+		Reset();
+		return false;
+	}
+
+	multimap<idx_t, idx_t> temporary_vacuum_buffers;
+	D_ASSERT(vacuum_buffers.empty());
+	idx_t available_segments_in_memory = 0;
+
+	for (auto &buffer : buffers) {
+		buffer.second.vacuum = false;
+		if (buffer.second.InMemory()) {
+			auto available_segments_in_buffer = available_segments_per_buffer - buffer.second.segment_count;
+			available_segments_in_memory += available_segments_in_buffer;
+			temporary_vacuum_buffers.emplace(available_segments_in_buffer, buffer.first);
+		}
+	}
+
+	// no buffers in memory
+	if (temporary_vacuum_buffers.empty()) {
+		return false;
+	}
+
+	auto excess_buffer_count = available_segments_in_memory / available_segments_per_buffer;
+
+	// calculate the vacuum threshold adaptively
+	D_ASSERT(excess_buffer_count < temporary_vacuum_buffers.size());
+	idx_t memory_usage = GetMemoryUsage();
+	idx_t excess_memory_usage = excess_buffer_count * Storage::BLOCK_SIZE;
+	auto excess_percentage = double(excess_memory_usage) / double(memory_usage);
+	auto threshold = double(VACUUM_THRESHOLD) / 100.0;
+	if (excess_percentage < threshold) {
+		return false;
+	}
+
+	D_ASSERT(excess_buffer_count <= temporary_vacuum_buffers.size());
+	D_ASSERT(temporary_vacuum_buffers.size() <= buffers.size());
+
+	// erasing from a multimap, we vacuum the buffers with the most free spaces (least full)
+	while (temporary_vacuum_buffers.size() != excess_buffer_count) {
+		temporary_vacuum_buffers.erase(temporary_vacuum_buffers.begin());
+	}
+
+	// adjust the buffers, and erase all to-be-vacuumed buffers from the available buffer list
+	for (auto &vacuum_buffer : temporary_vacuum_buffers) {
+		auto buffer_id = vacuum_buffer.second;
+		D_ASSERT(buffers.find(buffer_id) != buffers.end());
+		buffers.find(buffer_id)->second.vacuum = true;
+		buffers_with_free_space.erase(buffer_id);
+	}
+
+	for (auto &vacuum_buffer : temporary_vacuum_buffers) {
+		vacuum_buffers.insert(vacuum_buffer.second);
+	}
+
+	return true;
+}
+
+void FixedSizeAllocator::FinalizeVacuum() {
+
+	for (auto &buffer_id : vacuum_buffers) {
+		D_ASSERT(buffers.find(buffer_id) != buffers.end());
+		auto &buffer = buffers.find(buffer_id)->second;
+		D_ASSERT(buffer.InMemory());
+		buffer.Destroy();
+		buffers.erase(buffer_id);
+	}
+	vacuum_buffers.clear();
+}
+
+IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer ptr) {
+
+	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
+	// buffer after the vacuum operation
+
+	auto new_ptr = New();
+	// new increases the allocation count, we need to counter that here
+	total_segment_count--;
+
+	memcpy(Get(new_ptr), Get(ptr), segment_size);
+	return new_ptr;
+}
+
+BlockPointer FixedSizeAllocator::Serialize(MetadataWriter &writer) {
+
+	for (auto &buffer : buffers) {
+		buffer.second.Serialize();
+	}
+
+	auto block_pointer = writer.GetBlockPointer();
+	writer.Write(segment_size);
+	writer.Write(static_cast<idx_t>(buffers.size()));
+	writer.Write(static_cast<idx_t>(buffers_with_free_space.size()));
+
+	for (auto &buffer : buffers) {
+		writer.Write(buffer.first);
+		writer.Write(buffer.second.BlockId());
+		writer.Write(buffer.second.segment_count);
+	}
+	for (auto &buffer_id : buffers_with_free_space) {
+		writer.Write(buffer_id);
+	}
+
+	return block_pointer;
+}
+
+void FixedSizeAllocator::Deserialize(const BlockPointer &block_pointer) {
+
+	MetadataReader reader(metadata_manager, block_pointer);
+	segment_size = reader.Read<idx_t>();
+	auto buffer_count = reader.Read<idx_t>();
+	auto buffers_with_free_space_count = reader.Read<idx_t>();
+
+	total_segment_count = 0;
+
+	for (idx_t i = 0; i < buffer_count; i++) {
+		auto buffer_id = reader.Read<idx_t>();
+		auto block_id = reader.Read<block_id_t>();
+		auto buffer_segment_count = reader.Read<idx_t>();
+		FixedSizeBuffer new_buffer(block_manager, buffer_segment_count, block_id);
+		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
+		total_segment_count += buffer_segment_count;
+	}
+	for (idx_t i = 0; i < buffers_with_free_space_count; i++) {
+		buffers_with_free_space.insert(reader.Read<idx_t>());
+	}
+}
+
+uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t segment_count) {
+
+	auto data = mask.GetData();
+
+	// fills up a buffer sequentially before searching for free bits
+	if (mask.RowIsValid(segment_count)) {
+		mask.SetInvalid(segment_count);
+		return segment_count;
+	}
+
+	for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) {
+		// get an entry with free bits
+		if (data[entry_idx] == 0) {
+			continue;
+		}
+
+		// find the position of the free bit
+		auto entry = data[entry_idx];
+		idx_t first_valid_bit = 0;
+
+		// this loop finds the position of the rightmost set bit in entry and stores it
+		// in first_valid_bit
+		for (idx_t i = 0; i < 6; i++) {
+			// set the left half of the bits of this level to zero and test if the entry is still not zero
+			if (entry & BASE[i]) {
+				// first valid bit is in the rightmost s[i] bits
+				// permanently set the left half of the bits to zero
+				entry &= BASE[i];
+			} else {
+				// first valid bit is in the leftmost s[i] bits
+				// shift by s[i] for the next iteration and add s[i] to the position of the rightmost set bit
+				entry >>= SHIFT[i];
+				first_valid_bit += SHIFT[i];
+			}
+		}
+		D_ASSERT(entry);
+
+		auto prev_bits = entry_idx * sizeof(validity_t) * 8;
+		D_ASSERT(mask.RowIsValid(prev_bits + first_valid_bit));
+		mask.SetInvalid(prev_bits + first_valid_bit);
+		return (prev_bits + first_valid_bit);
+	}
+
+	throw InternalException("Invalid bitmask for FixedSizeAllocator");
+}
+
+idx_t FixedSizeAllocator::GetAvailableBufferId() const {
+	idx_t buffer_id = buffers.size();
+	while (buffers.find(buffer_id) != buffers.end()) {
+		D_ASSERT(buffer_id > 0);
+		buffer_id--;
+	}
+	return buffer_id;
+}
+
+idx_t FixedSizeAllocator::GetUpperBoundBufferId() const {
+	idx_t upper_bound_id = 0;
+	for (auto &buffer : buffers) {
+		if (buffer.first >= upper_bound_id) {
+			upper_bound_id = buffer.first + 1;
+		}
+	}
+	return upper_bound_id;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,74 @@
+#include "duckdb/execution/index/fixed_size_buffer.hpp"
+
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager)
+    : block_manager(block_manager), segment_count(0), dirty(false), vacuum(false), block_handle(nullptr) {
+
+	auto &buffer_manager = block_manager.buffer_manager;
+	buffer_handle = buffer_manager.Allocate(Storage::BLOCK_SIZE, false, &block_handle);
+}
+
+FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const block_id_t &block_id)
+    : block_manager(block_manager), segment_count(segment_count), dirty(false), vacuum(false) {
+
+	D_ASSERT(block_id < MAXIMUM_BLOCK);
+	block_handle = block_manager.RegisterBlock(block_id);
+	D_ASSERT(BlockId() < MAXIMUM_BLOCK);
+}
+
+void FixedSizeBuffer::Destroy() {
+	if (InMemory()) {
+		buffer_handle.Destroy();
+	}
+	if (OnDisk()) {
+		block_manager.MarkBlockAsFree(BlockId());
+	}
+}
+
+void FixedSizeBuffer::Serialize() {
+
+	if (!InMemory()) {
+		if (!OnDisk() || dirty) {
+			throw InternalException("invalid/missing buffer in FixedSizeAllocator");
+		}
+		return;
+	}
+	if (!dirty && OnDisk()) {
+		return;
+	}
+
+	// the buffer is in memory
+	D_ASSERT(InMemory());
+	// the buffer never was on disk, or there were changes to it after loading it from disk
+	D_ASSERT(!OnDisk() || dirty);
+
+	// we persist any changes, so the buffer is no longer dirty
+	dirty = false;
+
+	if (!OnDisk()) {
+		// temporary block - convert to persistent
+		auto block_id = block_manager.GetFreeBlockId();
+		D_ASSERT(block_id < MAXIMUM_BLOCK);
+		block_handle = block_manager.ConvertToPersistent(block_id, std::move(block_handle));
+		buffer_handle.Destroy();
+
+	} else {
+		// already a persistent block - only need to write it
+		auto block_id = block_handle->BlockId();
+		D_ASSERT(block_id < MAXIMUM_BLOCK);
+		block_manager.Write(buffer_handle.GetFileBuffer(), block_id);
+	}
+}
+
+void FixedSizeBuffer::Pin() {
+
+	auto &buffer_manager = block_manager.buffer_manager;
+	D_ASSERT(BlockId() < MAXIMUM_BLOCK);
+	buffer_handle = BufferHandle(buffer_manager.Pin(block_handle));
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -564,7 +564,7 @@ WindowGlobalSourceState::Task WindowGlobalSourceState::NextTask(idx_t hash_bin)
 
 		//	If there is nothing to steal but there are unfinished partitions,
 		//	yield until any pending builds are done.
-		TaskScheduler::GetScheduler(context).YieldThread();
+		TaskScheduler::YieldThread();
 	}
 
 	return Task();

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

@@ -89,7 +89,7 @@ SinkResultType PhysicalCreateARTIndex::SinkUnsorted(Vector &row_identifiers, Ope
 	// insert the row IDs
 	auto &art = l_state.local_index->Cast<ART>();
 	for (idx_t i = 0; i < count; i++) {
-		if (!art.Insert(*art.tree, l_state.keys[i], 0, row_ids[i])) {
+		if (!art.Insert(art.tree, l_state.keys[i], 0, row_ids[i])) {
 			throw ConstraintException("Data contains duplicates on indexed column(s)");
 		}
 	}

package/src/duckdb/src/function/table/system/duckdb_columns.cpp

@@ -131,7 +131,9 @@ public:
 	}
 	const Value ColumnDefault(idx_t col) override {
 		auto &column = entry.GetColumn(LogicalIndex(col));
-		if (column.DefaultValue()) {
+		if (column.Generated()) {
+			return Value(column.GeneratedExpression().ToString());
+		} else if (column.DefaultValue()) {
 			return Value(column.DefaultValue()->ToString());
 		}
 		return Value();

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev4025"
+#define DUCKDB_VERSION "0.8.2-dev4142"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "9698e9e6a8"
+#define DUCKDB_SOURCE_ID "d5c4422f72"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -305,6 +305,7 @@ public:
 	static void AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name);
 	//! Autoload the extension required for `function_name` or throw a CatalogException
 	static bool AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogType type, const string &entry_name);
+	DUCKDB_API static bool TryAutoLoad(ClientContext &context, const string &extension_name) noexcept;
 
 protected:
 	//! Reference to the database

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp

@@ -24,6 +24,8 @@ public:
 public:
 	string GetSchemaName() const override;
 	string GetTableName() const override;
+	//! This drops in-memory index data and marks all blocks on disk as free blocks, allowing to reclaim them
+	void CommitDrop();
 };
 
 } // namespace duckdb

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

@@ -34,7 +34,7 @@ public:
 	void Invalidate() {
 		index = INVALID_INDEX;
 	}
-	idx_t GetIndex() {
+	idx_t GetIndex() const {
 		if (index == INVALID_INDEX) {
 			throw InternalException("Attempting to get the index of an optional_idx that is not set");
 		}

package/src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp

@@ -219,4 +219,55 @@ struct ListRangeFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct ListCosineSimilarityFun {
+	static constexpr const char *Name = "list_cosine_similarity";
+	static constexpr const char *Parameters = "list1,list2";
+	static constexpr const char *Description = "Compute the cosine similarity between two lists.";
+	static constexpr const char *Example = "list_cosine_similarity([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ListCosineSimilarityFunAlias {
+	using ALIAS = ListCosineSimilarityFun;
+
+	static constexpr const char *Name = "<=>";
+};
+
+struct ListDistanceFun {
+	static constexpr const char *Name = "list_distance";
+	static constexpr const char *Parameters = "list1,list2";
+	static constexpr const char *Description = "Compute the distance between two lists.";
+	static constexpr const char *Example = "list_distance([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ListDistanceFunAlias {
+	using ALIAS = ListDistanceFun;
+
+	static constexpr const char *Name = "<->";
+};
+
+struct ListInnerProductFun {
+	static constexpr const char *Name = "list_inner_product";
+	static constexpr const char *Parameters = "list1,list2";
+	static constexpr const char *Description = "Compute the inner product between two lists.";
+	static constexpr const char *Example = "list_inner_product([1, 2, 3], [1, 2, 3])";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
+struct ListDotProductFun {
+	using ALIAS = ListInnerProductFun;
+
+	static constexpr const char *Name = "list_dot_product";
+};
+
+struct ListInnerProductFunAlias {
+	using ALIAS = ListInnerProductFun;
+
+	static constexpr const char *Name = "<#>";
+};
+
 } // namespace duckdb

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

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/storage/index.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/common/array.hpp"
 
 namespace duckdb {
 
@@ -19,7 +21,6 @@ enum class VerifyExistenceType : uint8_t {
 	DELETE_FK = 2  // delete from a table that has a foreign key
 };
 class ConflictManager;
-class Node;
 class ARTKey;
 class FixedSizeAllocator;
 
@@ -31,18 +32,22 @@ struct ARTFlags {
 };
 
 class ART : public Index {
+public:
+	//! FixedSizeAllocator count of the ART
+	static constexpr uint8_t ALLOCATOR_COUNT = 6;
+
 public:
 	//! Constructs an ART
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
-	    AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr = nullptr,
-	    BlockPointer block = BlockPointer());
-	~ART() override;
+	    AttachedDatabase &db,
+	    const shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr = nullptr,
+	    const BlockPointer &block = BlockPointer());
 
 	//! Root of the tree
-	unique_ptr<Node> tree;
+	Node tree = Node();
 	//! Fixed-size allocators holding the ART nodes
-	shared_ptr<vector<FixedSizeAllocator>> allocators;
+	shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> allocators;
 	//! True, if the ART owns its data
 	bool owns_data;
 
@@ -66,6 +71,8 @@ public:
 	void VerifyAppend(DataChunk &chunk) override;
 	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
 	void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) override;
+	//! Deletes all data from the index. The lock obtained from InitializeLock must be held
+	void CommitDrop(IndexLock &index_lock) override;
 	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Insert a chunk of entries into the index
@@ -103,7 +110,7 @@ public:
 	string VerifyAndToString(IndexLock &state, const bool only_verify) override;
 
 	//! Find the node with a matching key, or return nullptr if not found
-	Node Lookup(Node node, const ARTKey &key, idx_t depth);
+	optional_ptr<const Node> Lookup(const Node &node, const ARTKey &key, idx_t depth);
 	//! Insert a key into the tree
 	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 
@@ -136,6 +143,9 @@ private:
 	//! Internal function to return the string representation of the ART,
 	//! or only traverses and verifies the index
 	string VerifyAndToStringInternal(const bool only_verify);
+
+	//! Deserialize the allocators of the ART
+	void Deserialize(const BlockPointer &pointer);
 };
 
 } // namespace duckdb

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

@@ -41,11 +41,11 @@ public:
 		return key_bytes[idx];
 	}
 	//! Greater than operator
-	bool operator>(const ARTKey &k) const;
+	bool operator>(const ARTKey &key) const;
 	//! Greater than or equal to operator
-	bool operator>=(const ARTKey &k) const;
+	bool operator>=(const ARTKey &key) const;
 	//! Equal to operator
-	bool operator==(const ARTKey &k) const;
+	bool operator==(const ARTKey &key) const;
 
 private:
 	vector<uint8_t> key_bytes;
@@ -62,10 +62,10 @@ public:
 	//! If upper_bound is the empty ARTKey, than there is no upper bound
 	bool Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row_t> &result_ids, const bool equal);
 	//! Finds the minimum (leaf) of the current subtree
-	void FindMinimum(Node &node);
+	void FindMinimum(const Node &node);
 	//! Finds the lower bound of the ART and adds the nodes to the stack. Returns false, if the lower
 	//! bound exceeds the maximum value of the ART
-	bool LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t depth);
+	bool LowerBound(const Node &node, const ARTKey &key, const bool equal, idx_t depth);
 
 private:
 	//! Stack of nodes from the root to the currently active node