duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -3,9 +3,8 @@
 #include "duckdb/core_functions/aggregate/holistic_functions.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/queue.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 #include <algorithm>
 #include <stdlib.h>
@@ -70,28 +69,14 @@ struct ReservoirQuantileBindData : public FunctionData {
 		return quantiles == other.quantiles && sample_size == other.sample_size;
 	}
 
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
-		D_ASSERT(bind_data_p);
-		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
-		writer.WriteList<double>(bind_data.quantiles);
-		writer.WriteField<int32_t>(bind_data.sample_size);
-	}
-
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &bound_function) {
-		auto quantiles = reader.ReadRequiredList<double>();
-		auto sample_size = reader.ReadRequired<int32_t>();
-		return make_uniq<ReservoirQuantileBindData>(std::move(quantiles), sample_size);
-	}
-
-	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                            const AggregateFunction &function) {
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
 		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
 		serializer.WriteProperty(101, "sample_size", bind_data.sample_size);
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<ReservoirQuantileBindData>();
 		deserializer.ReadProperty(100, "quantiles", result->quantiles);
 		deserializer.ReadProperty(101, "sample_size", result->sample_size);
@@ -373,8 +358,6 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, Ag
 	function.name = "reservoir_quantile";
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	return bind_data;
 }
 
@@ -383,8 +366,6 @@ AggregateFunction GetReservoirQuantileAggregate(PhysicalType type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	fun.arguments.emplace_back(LogicalType::DOUBLE);
 	return fun;
@@ -396,8 +377,6 @@ unique_ptr<FunctionData> BindReservoirQuantileDecimalList(ClientContext &context
 	auto bind_data = BindReservoirQuantile(context, function, arguments);
 	function.serialize = ReservoirQuantileBindData::Serialize;
 	function.deserialize = ReservoirQuantileBindData::Deserialize;
-	function.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	function.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	function.name = "reservoir_quantile";
 	return bind_data;
 }
@@ -407,8 +386,6 @@ AggregateFunction GetReservoirQuantileListAggregate(const LogicalType &type) {
 	fun.bind = BindReservoirQuantile;
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	// temporarily push an argument so we can bind the actual quantile
 	auto list_of_double = LogicalType::LIST(LogicalType::DOUBLE);
 	fun.arguments.push_back(list_of_double);
@@ -437,8 +414,6 @@ static void GetReservoirQuantileDecimalFunction(AggregateFunctionSet &set, const
 	                      BindReservoirQuantileDecimal);
 	fun.serialize = ReservoirQuantileBindData::Serialize;
 	fun.deserialize = ReservoirQuantileBindData::Deserialize;
-	fun.format_serialize = ReservoirQuantileBindData::FormatSerialize;
-	fun.format_deserialize = ReservoirQuantileBindData::FormatDeserialize;
 	set.AddFunction(fun);
 
 	fun.arguments.emplace_back(LogicalType::INTEGER);

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -11,8 +11,6 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
@@ -1603,18 +1601,17 @@ struct StructDatePart {
 		result.Verify(count);
 	}
 
-	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
+	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                              const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
 		auto &info = bind_data_p->Cast<BindData>();
-		writer.WriteSerializable(info.stype);
-		writer.WriteList<DatePartSpecifier>(info.part_codes);
+		serializer.WriteProperty(100, "stype", info.stype);
+		serializer.WriteProperty(101, "part_codes", info.part_codes);
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
-	                                                    ScalarFunction &bound_function) {
-		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();
+	static unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		auto part_codes = deserializer.ReadProperty<vector<DatePartSpecifier>>(101, "part_codes");
 		return make_uniq<BindData>(std::move(stype), std::move(part_codes));
 	}
 

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -36,25 +36,30 @@ struct ListAggregatesBindData : public FunctionData {
 		auto &other = other_p.Cast<ListAggregatesBindData>();
 		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
 	}
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p);
-		if (!bind_data) {
-			writer.WriteField<bool>(false);
-		} else {
-			writer.WriteField<bool>(true);
-			writer.WriteSerializable(bind_data->stype);
-			writer.WriteSerializable(*bind_data->aggr_expr);
-		}
+	void Serialize(Serializer &serializer) const {
+		serializer.WriteProperty(1, "stype", stype);
+		serializer.WriteProperty(2, "aggr_expr", aggr_expr);
+	}
+	static unique_ptr<ListAggregatesBindData> Deserialize(Deserializer &deserializer) {
+		auto stype = deserializer.ReadProperty<LogicalType>(1, "stype");
+		auto aggr_expr = deserializer.ReadProperty<unique_ptr<Expression>>(2, "aggr_expr");
+		auto result = make_uniq<ListAggregatesBindData>(std::move(stype), std::move(aggr_expr));
+		return result;
 	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            ScalarFunction &bound_function) {
-		if (reader.ReadRequired<bool>()) {
-			auto s_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-			auto expr = reader.ReadRequiredSerializable<Expression>(state);
-			return make_uniq<ListAggregatesBindData>(s_type, std::move(expr));
-		} else {
+
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function) {
+		auto bind_data = dynamic_cast<const ListAggregatesBindData *>(bind_data_p.get());
+		serializer.WritePropertyWithDefault(100, "bind_data", bind_data, (const ListAggregatesBindData *)nullptr);
+	}
+
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto result = deserializer.ReadPropertyWithDefault<unique_ptr<ListAggregatesBindData>>(
+		    100, "bind_data", unique_ptr<ListAggregatesBindData>(nullptr));
+		if (!result) {
 			return ListAggregatesBindFailure(bound_function);
 		}
+		return std::move(result);
 	}
 };
 

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -8,8 +8,8 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -23,26 +23,22 @@ struct ListLambdaBindData : public FunctionData {
 public:
 	bool Equals(const FunctionData &other_p) const override;
 	unique_ptr<FunctionData> Copy() const override;
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
-		throw NotImplementedException("FIXME: list lambda serialize");
-	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            ScalarFunction &bound_function) {
-		throw NotImplementedException("FIXME: list lambda deserialize");
-	}
 
-	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-	                            const ScalarFunction &function) {
-		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
-		serializer.WriteProperty(100, "stype", bind_data.stype);
-		serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr, unique_ptr<Expression>());
+	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                      const ScalarFunction &function) {
+		//		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
+		//		serializer.WriteProperty(100, "stype", bind_data.stype);
+		//		serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr,
+		// unique_ptr<Expression>());
+		throw NotImplementedException("FIXME: list lambda serialize");
 	}
 
-	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
-		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
-		auto lambda_expr =
-		    deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "lambda_expr", unique_ptr<Expression>());
-		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, ScalarFunction &function) {
+		//		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		//		auto lambda_expr =
+		//		    deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(101, "lambda_expr",
+		// unique_ptr<Expression>()); 		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
 };
 
@@ -401,8 +397,6 @@ ScalarFunction ListTransformFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.format_serialize = ListLambdaBindData::FormatSerialize;
-	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -412,8 +406,6 @@ ScalarFunction ListFilterFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	fun.format_serialize = ListLambdaBindData::FormatSerialize;
-	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 

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