duckdb 0.8.2-dev4203.0 → 0.8.2-dev4376.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev4203.0",
+  "version": "0.8.2-dev4376.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -118,7 +118,7 @@ struct ParquetWriteBindData : public TableFunctionData {
 	vector<LogicalType> sql_types;
 	vector<string> column_names;
 	duckdb_parquet::format::CompressionCodec::type codec = duckdb_parquet::format::CompressionCodec::SNAPPY;
-	idx_t row_group_size = RowGroup::ROW_GROUP_SIZE;
+	idx_t row_group_size = Storage::ROW_GROUP_SIZE;
 
 	//! If row_group_size_bytes is not set, we default to row_group_size * BYTES_PER_ROW
 	static constexpr const idx_t BYTES_PER_ROW = 1024;

package/src/duckdb/src/common/enum_util.cpp

@@ -551,6 +551,8 @@ BindingMode EnumUtil::FromString<BindingMode>(const char *value) {
 template<>
 const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value) {
 	switch(value) {
+	case BitpackingMode::INVALID:
+		return "INVALID";
 	case BitpackingMode::AUTO:
 		return "AUTO";
 	case BitpackingMode::CONSTANT:
@@ -568,6 +570,9 @@ const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value) {
 
 template<>
 BitpackingMode EnumUtil::FromString<BitpackingMode>(const char *value) {
+	if (StringUtil::Equals(value, "INVALID")) {
+		return BitpackingMode::INVALID;
+	}
 	if (StringUtil::Equals(value, "AUTO")) {
 		return BitpackingMode::AUTO;
 	}

package/src/duckdb/src/common/file_buffer.cpp

@@ -5,7 +5,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/helper.hpp"
-
+#include "duckdb/storage/storage_info.hpp"
 #include <cstring>
 
 namespace duckdb {

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -100,11 +100,30 @@ PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
 	}
 
 	if (!orders.empty()) {
-		auto types = payload_types;
-		types.push_back(LogicalType::HASH);
-		grouping_types.Initialize(types);
+		if (partitions.empty()) {
+			//	Sort early into a dedicated hash group if we only sort.
+			grouping_types.Initialize(payload_types);
+			auto new_group =
+			    make_uniq<PartitionGlobalHashGroup>(buffer_manager, partitions, orders, payload_types, external);
+			hash_groups.emplace_back(std::move(new_group));
+		} else {
+			auto types = payload_types;
+			types.push_back(LogicalType::HASH);
+			grouping_types.Initialize(types);
+			ResizeGroupingData(estimated_cardinality);
+		}
+	}
+}
 
-		ResizeGroupingData(estimated_cardinality);
+bool PartitionGlobalSinkState::HasMergeTasks() const {
+	if (grouping_data) {
+		auto &groups = grouping_data->GetPartitions();
+		return !groups.empty();
+	} else if (!hash_groups.empty()) {
+		D_ASSERT(hash_groups.size() == 1);
+		return hash_groups[0]->count > 0;
+	} else {
+		return false;
 	}
 }
 
@@ -206,6 +225,12 @@ PartitionLocalMergeState::PartitionLocalMergeState(PartitionGlobalSinkState &gst
 }
 
 void PartitionLocalMergeState::Scan() {
+	if (!merge_state->group_data) {
+		//	OVER(ORDER BY...)
+		//	Already sorted
+		return;
+	}
+
 	auto &group_data = *merge_state->group_data;
 	auto &hash_group = *merge_state->hash_group;
 	auto &chunk_state = merge_state->chunk_state;
@@ -243,13 +268,26 @@ PartitionLocalSinkState::PartitionLocalSinkState(ClientContext &context, Partiti
 	sort_cols = gstate.orders.size() + group_types.size();
 
 	if (sort_cols) {
+		auto payload_types = gstate.payload_types;
 		if (!group_types.empty()) {
 			// OVER(PARTITION BY...)
 			group_chunk.Initialize(allocator, group_types);
+			payload_types.emplace_back(LogicalType::HASH);
+		} else {
+			// OVER(ORDER BY...)
+			for (idx_t ord_idx = 0; ord_idx < gstate.orders.size(); ord_idx++) {
+				auto &pexpr = *gstate.orders[ord_idx].expression.get();
+				group_types.push_back(pexpr.return_type);
+				executor.AddExpression(pexpr);
+			}
+			group_chunk.Initialize(allocator, group_types);
+
+			//	Single partition
+			auto &global_sort = *gstate.hash_groups[0]->global_sort;
+			local_sort = make_uniq<LocalSortState>();
+			local_sort->Initialize(global_sort, global_sort.buffer_manager);
 		}
 		// OVER(...)
-		auto payload_types = gstate.payload_types;
-		payload_types.emplace_back(LogicalType::HASH);
 		payload_chunk.Initialize(allocator, payload_types);
 	} else {
 		// OVER()
@@ -259,20 +297,14 @@ PartitionLocalSinkState::PartitionLocalSinkState(ClientContext &context, Partiti
 
 void PartitionLocalSinkState::Hash(DataChunk &input_chunk, Vector &hash_vector) {
 	const auto count = input_chunk.size();
-	if (group_chunk.ColumnCount() > 0) {
-		// OVER(PARTITION BY...) (hash grouping)
-		group_chunk.Reset();
-		executor.Execute(input_chunk, group_chunk);
-		VectorOperations::Hash(group_chunk.data[0], hash_vector, count);
-		for (idx_t prt_idx = 1; prt_idx < group_chunk.ColumnCount(); ++prt_idx) {
-			VectorOperations::CombineHash(hash_vector, group_chunk.data[prt_idx], count);
-		}
-	} else {
-		// OVER(...) (sorting)
-		// Single partition => single hash value
-		hash_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto hashes = ConstantVector::GetData<hash_t>(hash_vector);
-		hashes[0] = 0;
+	D_ASSERT(group_chunk.ColumnCount() > 0);
+
+	// OVER(PARTITION BY...) (hash grouping)
+	group_chunk.Reset();
+	executor.Execute(input_chunk, group_chunk);
+	VectorOperations::Hash(group_chunk.data[0], hash_vector, count);
+	for (idx_t prt_idx = 1; prt_idx < group_chunk.ColumnCount(); ++prt_idx) {
+		VectorOperations::CombineHash(hash_vector, group_chunk.data[prt_idx], count);
 	}
 }
 
@@ -306,6 +338,22 @@ void PartitionLocalSinkState::Sink(DataChunk &input_chunk) {
 		return;
 	}
 
+	if (local_sort) {
+		//	OVER(ORDER BY...)
+		group_chunk.Reset();
+		executor.Execute(input_chunk, group_chunk);
+		local_sort->SinkChunk(group_chunk, input_chunk);
+
+		auto &hash_group = *gstate.hash_groups[0];
+		hash_group.count += input_chunk.size();
+
+		if (local_sort->SizeInBytes() > gstate.memory_per_thread) {
+			auto &global_sort = *hash_group.global_sort;
+			local_sort->Sort(global_sort, true);
+		}
+		return;
+	}
+
 	// OVER(...)
 	payload_chunk.Reset();
 	auto &hash_vector = payload_chunk.data.back();
@@ -338,6 +386,15 @@ void PartitionLocalSinkState::Combine() {
 		return;
 	}
 
+	if (local_sort) {
+		//	OVER(ORDER BY...)
+		auto &hash_group = *gstate.hash_groups[0];
+		auto &global_sort = *hash_group.global_sort;
+		global_sort.AddLocalState(*local_sort);
+		local_sort.reset();
+		return;
+	}
+
 	// OVER(...)
 	gstate.CombineLocalPartition(local_partition, local_append);
 }
@@ -365,6 +422,19 @@ PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &s
 	group_data->InitializeScan(chunk_state, column_ids);
 }
 
+PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink)
+    : sink(sink), memory_per_thread(sink.memory_per_thread),
+      num_threads(TaskScheduler::GetScheduler(sink.context).NumberOfThreads()), stage(PartitionSortStage::INIT),
+      total_tasks(0), tasks_assigned(0), tasks_completed(0) {
+
+	const hash_t hash_bin = 0;
+	const size_t group_idx = 0;
+	hash_group = sink.hash_groups[group_idx].get();
+	global_sort = sink.hash_groups[group_idx]->global_sort.get();
+
+	sink.bin_groups[hash_bin] = group_idx;
+}
+
 void PartitionLocalMergeState::Prepare() {
 	merge_state->group_data.reset();
 
@@ -390,7 +460,7 @@ void PartitionLocalMergeState::ExecuteTask() {
 		Merge();
 		break;
 	default:
-		throw InternalException("Unexpected PartitionGlobalMergeState in ExecuteTask!");
+		throw InternalException("Unexpected PartitionSortStage in ExecuteTask!");
 	}
 
 	merge_state->CompleteTask();
@@ -471,15 +541,23 @@ bool PartitionGlobalMergeState::TryPrepareNextStage() {
 
 PartitionGlobalMergeStates::PartitionGlobalMergeStates(PartitionGlobalSinkState &sink) {
 	// Schedule all the sorts for maximum thread utilisation
-	auto &partitions = sink.grouping_data->GetPartitions();
-	sink.bin_groups.resize(partitions.size(), partitions.size());
-	for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
-		auto &group_data = partitions[hash_bin];
-		// Prepare for merge sort phase
-		if (group_data->Count()) {
-			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
-			states.emplace_back(std::move(state));
+	if (sink.grouping_data) {
+		auto &partitions = sink.grouping_data->GetPartitions();
+		sink.bin_groups.resize(partitions.size(), partitions.size());
+		for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
+			auto &group_data = partitions[hash_bin];
+			// Prepare for merge sort phase
+			if (group_data->Count()) {
+				auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
+				states.emplace_back(std::move(state));
+			}
 		}
+	} else {
+		//	OVER(ORDER BY...)
+		//	Already sunk into the single global sort, so set up single merge with no data
+		sink.bin_groups.resize(1, 1);
+		auto state = make_uniq<PartitionGlobalMergeState>(sink);
+		states.emplace_back(std::move(state));
 	}
 }
 

package/src/duckdb/src/common/types/validity_mask.cpp

@@ -1,4 +1,7 @@
 #include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/common/limits.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
+#include "duckdb/common/serializer/read_stream.hpp"
 
 namespace duckdb {
 
@@ -173,4 +176,57 @@ void ValidityMask::SliceInPlace(const ValidityMask &other, idx_t target_offset,
 #endif
 }
 
+enum class ValiditySerialization : uint8_t { BITMASK = 0, VALID_VALUES = 1, INVALID_VALUES = 2 };
+
+void ValidityMask::Write(WriteStream &writer, idx_t count) {
+	auto valid_values = CountValid(count);
+	auto invalid_values = count - valid_values;
+	auto bitmask_bytes = ValidityMask::ValidityMaskSize(count);
+	auto need_u32 = count >= NumericLimits<uint16_t>::Maximum();
+	auto bytes_per_value = need_u32 ? sizeof(uint32_t) : sizeof(uint16_t);
+	auto valid_value_size = bytes_per_value * valid_values + sizeof(uint32_t);
+	auto invalid_value_size = bytes_per_value * invalid_values + sizeof(uint32_t);
+	if (valid_value_size < bitmask_bytes || invalid_value_size < bitmask_bytes) {
+		auto serialize_valid = valid_value_size < invalid_value_size;
+		// serialize (in)valid value indexes as [COUNT][V0][V1][...][VN]
+		auto flag = serialize_valid ? ValiditySerialization::VALID_VALUES : ValiditySerialization::INVALID_VALUES;
+		writer.Write(flag);
+		writer.Write<uint32_t>(MinValue<uint32_t>(valid_values, invalid_values));
+		for (idx_t i = 0; i < count; i++) {
+			if (RowIsValid(i) == serialize_valid) {
+				if (need_u32) {
+					writer.Write<uint32_t>(i);
+				} else {
+					writer.Write<uint16_t>(i);
+				}
+			}
+		}
+	} else {
+		// serialize the entire bitmask
+		writer.Write(ValiditySerialization::BITMASK);
+		writer.WriteData(const_data_ptr_cast(GetData()), bitmask_bytes);
+	}
+}
+
+void ValidityMask::Read(ReadStream &reader, idx_t count) {
+	Initialize(count);
+	// deserialize the storage type
+	auto flag = reader.Read<ValiditySerialization>();
+	if (flag == ValiditySerialization::BITMASK) {
+		// deserialize the bitmask
+		reader.ReadData(data_ptr_cast(GetData()), ValidityMask::ValidityMaskSize(count));
+		return;
+	}
+	auto is_u32 = count >= NumericLimits<uint16_t>::Maximum();
+	auto is_valid = flag == ValiditySerialization::VALID_VALUES;
+	auto serialize_count = reader.Read<uint32_t>();
+	if (is_valid) {
+		SetAllInvalid(count);
+	}
+	for (idx_t i = 0; i < serialize_count; i++) {
+		idx_t index = is_u32 ? reader.Read<uint32_t>() : reader.Read<uint16_t>();
+		Set(index, is_valid);
+	}
+}
+
 } // namespace duckdb

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

@@ -985,10 +985,14 @@ BlockPointer ART::Serialize(MetadataWriter &writer) {
 	}
 
 	lock_guard<mutex> l(lock);
+	auto &block_manager = table_io_manager.GetIndexBlockManager();
+	PartialBlockManager partial_block_manager(block_manager, CheckpointType::FULL_CHECKPOINT);
+
 	vector<BlockPointer> allocator_pointers;
 	for (auto &allocator : *allocators) {
-		allocator_pointers.push_back(allocator->Serialize(writer));
+		allocator_pointers.push_back(allocator->Serialize(partial_block_manager, writer));
 	}
+	partial_block_manager.FlushPartialBlocks();
 
 	root_block_pointer = writer.GetBlockPointer();
 	writer.Write(tree);

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

@@ -26,6 +26,7 @@ void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t coun
 		auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 
 		leaf.count = MinValue((idx_t)Node::LEAF_SIZE, count);
+
 		for (idx_t i = 0; i < leaf.count; i++) {
 			leaf.row_ids[i] = row_ids[copy_count + i];
 		}
@@ -38,6 +39,16 @@ void Leaf::New(ART &art, reference<Node> &node, const row_t *row_ids, idx_t coun
 	}
 }
 
+Leaf &Leaf::New(ART &art, Node &node) {
+	node = Node::GetAllocator(art, NType::LEAF).New();
+	node.SetMetadata(static_cast<uint8_t>(NType::LEAF));
+	auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
+
+	leaf.count = 0;
+	leaf.ptr.Clear();
+	return leaf;
+}
+
 void Leaf::Free(ART &art, Node &node) {
 
 	Node current_node = node;
@@ -313,13 +324,10 @@ void Leaf::MoveInlinedToLeaf(ART &art, Node &node) {
 
 	D_ASSERT(node.GetType() == NType::LEAF_INLINED);
 	auto row_id = node.GetRowId();
-	node = Node::GetAllocator(art, NType::LEAF).New();
-	node.SetMetadata(static_cast<uint8_t>(NType::LEAF));
+	auto &leaf = New(art, node);
 
-	auto &leaf = Node::RefMutable<Leaf>(art, node, NType::LEAF);
 	leaf.count = 1;
 	leaf.row_ids[0] = row_id;
-	leaf.ptr.Clear();
 }
 
 Leaf &Leaf::Append(ART &art, const row_t row_id) {
@@ -328,12 +336,7 @@ Leaf &Leaf::Append(ART &art, const row_t row_id) {
 
 	// we need a new leaf node
 	if (leaf.get().count == Node::LEAF_SIZE) {
-		leaf.get().ptr = Node::GetAllocator(art, NType::LEAF).New();
-		leaf.get().ptr.SetMetadata(static_cast<uint8_t>(NType::LEAF));
-
-		leaf = Node::RefMutable<Leaf>(art, leaf.get().ptr, NType::LEAF);
-		leaf.get().count = 0;
-		leaf.get().ptr.Clear();
+		leaf = New(art, leaf.get().ptr);
 	}
 
 	leaf.get().row_ids[leaf.get().count] = row_id;

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

@@ -15,8 +15,6 @@ Node48 &Node48::New(ART &art, Node &node) {
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n48.child_index[i] = Node::EMPTY_MARKER;
 	}
-
-	// necessary for faster child insertion/deletion
 	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
 		n48.children[i].Clear();
 	}

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

@@ -4,9 +4,6 @@
 
 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) {
@@ -61,25 +58,36 @@ IndexPointer FixedSizeAllocator::New() {
 		D_ASSERT(buffers.find(buffer_id) != buffers.end());
 		auto &buffer = buffers.find(buffer_id)->second;
 		ValidityMask mask(reinterpret_cast<validity_t *>(buffer.Get()));
+
+		// zero-initialize the bitmask to avoid leaking memory to disk
+		auto data = mask.GetData();
+		for (idx_t i = 0; i < bitmask_count; i++) {
+			data[i] = 0;
+		}
+
+		// initializing the bitmask of the new buffer
 		mask.SetAllValid(available_segments_per_buffer);
 	}
 
-	// return a pointer
+	// return a pointer to a free segment
 	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);
+	auto offset = buffer.GetOffset(bitmask_count);
 
-	buffer.segment_count++;
 	total_segment_count++;
+	buffer.segment_count++;
 	if (buffer.segment_count == available_segments_per_buffer) {
 		buffers_with_free_space.erase(buffer_id);
 	}
 
+	// zero-initialize that segment
+	auto buffer_ptr = buffer.Get();
+	auto offset_in_buffer = buffer_ptr + offset * segment_size + bitmask_offset;
+	memset(offset_in_buffer, 0, segment_size);
+
 	return IndexPointer(buffer_id, offset);
 }
 
@@ -95,13 +103,14 @@ void FixedSizeAllocator::Free(const IndexPointer ptr) {
 	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--;
+	// adjust the allocator fields
+	buffers_with_free_space.insert(buffer_id);
 	total_segment_count--;
+	buffer.segment_count--;
 }
 
 void FixedSizeAllocator::Reset() {
@@ -123,6 +132,16 @@ idx_t FixedSizeAllocator::GetMemoryUsage() const {
 	return memory_usage;
 }
 
+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;
+}
+
 void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
 
 	D_ASSERT(segment_size == other.segment_size);
@@ -232,10 +251,10 @@ IndexPointer FixedSizeAllocator::VacuumPointer(const IndexPointer ptr) {
 	return new_ptr;
 }
 
-BlockPointer FixedSizeAllocator::Serialize(MetadataWriter &writer) {
+BlockPointer FixedSizeAllocator::Serialize(PartialBlockManager &partial_block_manager, MetadataWriter &writer) {
 
 	for (auto &buffer : buffers) {
-		buffer.second.Serialize();
+		buffer.second.Serialize(partial_block_manager, available_segments_per_buffer, segment_size, bitmask_offset);
 	}
 
 	auto block_pointer = writer.GetBlockPointer();
@@ -245,8 +264,9 @@ BlockPointer FixedSizeAllocator::Serialize(MetadataWriter &writer) {
 
 	for (auto &buffer : buffers) {
 		writer.Write(buffer.first);
-		writer.Write(buffer.second.BlockId());
+		writer.Write(buffer.second.block_pointer);
 		writer.Write(buffer.second.segment_count);
+		writer.Write(buffer.second.allocation_size);
 	}
 	for (auto &buffer_id : buffers_with_free_space) {
 		writer.Write(buffer_id);
@@ -266,63 +286,18 @@ void FixedSizeAllocator::Deserialize(const BlockPointer &block_pointer) {
 
 	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);
+		auto buffer_block_pointer = reader.Read<BlockPointer>();
+		auto segment_count = reader.Read<idx_t>();
+		auto allocation_size = reader.Read<idx_t>();
+		FixedSizeBuffer new_buffer(block_manager, segment_count, allocation_size, buffer_block_pointer);
 		buffers.insert(make_pair(buffer_id, std::move(new_buffer)));
-		total_segment_count += buffer_segment_count;
+		total_segment_count += 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()) {
@@ -332,14 +307,4 @@ idx_t FixedSizeAllocator::GetAvailableBufferId() const {
 	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