duckdb 0.8.2-dev77.0 → 0.9.0

package/src/duckdb/src/common/row_operations/row_match.cpp

@@ -1,359 +0,0 @@
-//===--------------------------------------------------------------------===//
-// row_match.cpp
-// Description: This file contains the implementation of the match operators
-//===--------------------------------------------------------------------===//
-
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/operator/constant_operators.hpp"
-#include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row/tuple_data_collection.hpp"
-
-namespace duckdb {
-
-using ValidityBytes = RowLayout::ValidityBytes;
-using Predicates = RowOperations::Predicates;
-
-template <typename OP>
-static idx_t SelectComparison(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                              SelectionVector *true_sel, SelectionVector *false_sel) {
-	throw NotImplementedException("Unsupported nested comparison operand for RowOperations::Match");
-}
-
-template <>
-idx_t SelectComparison<Equals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                               SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<NotEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::NestedNotEquals(left, right, sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<GreaterThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctGreaterThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThan>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                 SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <>
-idx_t SelectComparison<LessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
-                                       SelectionVector *true_sel, SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
-}
-
-template <class T, class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, SelectionVector &sel, idx_t &count,
-                               idx_t col_offset, idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
-	// Precompute row_mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	auto data = UnifiedVectorFormat::GetData<T>(col);
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	idx_t match_count = 0;
-	if (!col.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			auto col_idx = col.sel->get_index(idx);
-			if (!col.validity.RowIsValid(col_idx)) {
-				if (isnull) {
-					// match: move to next value to compare
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			} else {
-				auto value = Load<T>(row + col_offset);
-				if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			auto col_idx = col.sel->get_index(idx);
-			auto value = Load<T>(row + col_offset);
-			if (!isnull && OP::template Operation<T>(data[col_idx], value)) {
-				sel.set_index(match_count++, idx);
-			} else {
-				if (NO_MATCH_SEL) {
-					no_match->set_index(no_match_count++, idx);
-				}
-			}
-		}
-	}
-	count = match_count;
-}
-
-//! Forward declaration for recursion
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
-                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
-                             idx_t &no_match_count, const idx_t original_count);
-
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchStruct(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
-                                 SelectionVector &sel, idx_t &count, const idx_t col_no, SelectionVector *no_match,
-                                 idx_t &no_match_count, const idx_t original_count) {
-	// Precompute row_mask indexes
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
-
-	// Work our way through the validity of the whole struct
-	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
-	idx_t match_count = 0;
-	if (!col.validity.AllValid()) {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			auto col_idx = col.sel->get_index(idx);
-			if (!col.validity.RowIsValid(col_idx)) {
-				if (isnull) {
-					// match: move to next value to compare
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			} else {
-				if (!isnull) {
-					sel.set_index(match_count++, idx);
-				} else {
-					if (NO_MATCH_SEL) {
-						no_match->set_index(no_match_count++, idx);
-					}
-				}
-			}
-		}
-	} else {
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-
-			auto row = ptrs[idx];
-			ValidityBytes row_mask(row);
-			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
-
-			if (!isnull) {
-				sel.set_index(match_count++, idx);
-			} else {
-				if (NO_MATCH_SEL) {
-					no_match->set_index(no_match_count++, idx);
-				}
-			}
-		}
-	}
-	count = match_count;
-
-	// Now we construct row pointers to the structs
-	Vector struct_rows(LogicalTypeId::POINTER);
-	auto struct_ptrs = FlatVector::GetData<data_ptr_t>(struct_rows);
-
-	const auto col_offset = layout.GetOffsets()[col_no];
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto row = ptrs[idx];
-		struct_ptrs[idx] = row + col_offset;
-	}
-
-	// Get the struct layout, child columns, then recurse
-	const auto &struct_layout = layout.GetStructLayout(col_no);
-	auto &struct_entries = StructVector::GetEntries(vec);
-	D_ASSERT(struct_layout.ColumnCount() == struct_entries.size());
-	for (idx_t struct_col_no = 0; struct_col_no < struct_layout.ColumnCount(); struct_col_no++) {
-		auto &struct_vec = *struct_entries[struct_col_no];
-		UnifiedVectorFormat struct_col;
-		struct_vec.ToUnifiedFormat(original_count, struct_col);
-		TemplatedMatchOp<OP, NO_MATCH_SEL>(struct_vec, struct_col, struct_layout, struct_rows, sel, count,
-		                                   struct_col_no, no_match, no_match_count, original_count);
-	}
-}
-
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchList(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count,
-                               const TupleDataLayout &layout, const idx_t col_no, SelectionVector *no_match,
-                               idx_t &no_match_count) {
-	// Gather a dense Vector containing the column values being matched
-	Vector key(col.GetType());
-	const auto gather_function = TupleDataCollection::GetGatherFunction(col.GetType());
-	gather_function.function(layout, rows, col_no, sel, count, key, *FlatVector::IncrementalSelectionVector(), key,
-	                         gather_function.child_functions);
-
-	// Densify the input column
-	Vector sliced(col, sel, count);
-
-	if (NO_MATCH_SEL) {
-		SelectionVector no_match_sel_offset(no_match->data() + no_match_count);
-		auto match_count = SelectComparison<OP>(sliced, key, sel, count, &sel, &no_match_sel_offset);
-		no_match_count += count - match_count;
-		count = match_count;
-	} else {
-		count = SelectComparison<OP>(sliced, key, sel, count, &sel, nullptr);
-	}
-}
-
-template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
-                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
-                             idx_t &no_match_count, const idx_t original_count) {
-	if (count == 0) {
-		return;
-	}
-	auto col_offset = layout.GetOffsets()[col_no];
-	switch (layout.GetTypes()[col_no].InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedMatchType<int8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                             no_match_count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedMatchType<int16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedMatchType<int32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedMatchType<int64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedMatchType<uint8_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                              no_match_count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedMatchType<uint16_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedMatchType<uint32_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedMatchType<uint64_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedMatchType<hugeint_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                                no_match_count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedMatchType<float, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                            no_match_count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedMatchType<double, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                             no_match_count);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedMatchType<interval_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                                 no_match_count);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedMatchType<string_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
-		                                               no_match_count);
-		break;
-	case PhysicalType::STRUCT:
-		TemplatedMatchStruct<OP, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
-		                                       original_count);
-		break;
-	case PhysicalType::LIST:
-		TemplatedMatchList<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
-		break;
-	default:
-		throw InternalException("Unsupported column type for RowOperations::Match");
-	}
-}
-
-template <bool NO_MATCH_SEL>
-static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
-                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t &count,
-                           SelectionVector *no_match, idx_t &no_match_count) {
-	for (idx_t col_no = 0; col_no < predicates.size(); ++col_no) {
-		auto &vec = columns.data[col_no];
-		auto &col = col_data[col_no];
-		switch (predicates[col_no]) {
-		case ExpressionType::COMPARE_EQUAL:
-		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
-			                                       count);
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-			TemplatedMatchOp<NotEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                          no_match_count, count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHAN:
-			TemplatedMatchOp<GreaterThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                            no_match_count, count);
-			break;
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			TemplatedMatchOp<GreaterThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                                  no_match_count, count);
-			break;
-		case ExpressionType::COMPARE_LESSTHAN:
-			TemplatedMatchOp<LessThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                         no_match_count, count);
-			break;
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			TemplatedMatchOp<LessThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                               no_match_count, count);
-			break;
-		default:
-			throw InternalException("Unsupported comparison type for RowOperations::Match");
-		}
-	}
-}
-
-idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
-                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t count,
-                           SelectionVector *no_match, idx_t &no_match_count) {
-	if (no_match) {
-		TemplatedMatch<true>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
-	} else {
-		TemplatedMatch<false>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
-	}
-
-	return count;
-}
-
-} // namespace duckdb

package/src/duckdb/src/common/serializer/buffered_deserializer.cpp

@@ -1,27 +0,0 @@
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-BufferedDeserializer::BufferedDeserializer(data_ptr_t ptr, idx_t data_size) : ptr(ptr), endptr(ptr + data_size) {
-}
-
-BufferedDeserializer::BufferedDeserializer(BufferedSerializer &serializer)
-    : BufferedDeserializer(serializer.data, serializer.maximum_size) {
-	SetVersion(serializer.GetVersion());
-}
-
-void BufferedDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
-	if (ptr + read_size > endptr) {
-		throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
-	}
-	memcpy(buffer, ptr, read_size);
-	ptr += read_size;
-}
-
-ClientContext &BufferedContextDeserializer::GetContext() {
-	return context;
-}
-
-} // namespace duckdb

package/src/duckdb/src/common/serializer/buffered_serializer.cpp

@@ -1,36 +0,0 @@
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-BufferedSerializer::BufferedSerializer(idx_t maximum_size)
-    : BufferedSerializer(make_unsafe_uniq_array<data_t>(maximum_size), maximum_size) {
-}
-
-BufferedSerializer::BufferedSerializer(unsafe_unique_array<data_t> data, idx_t size)
-    : maximum_size(size), data(data.get()) {
-	blob.size = 0;
-	blob.data = std::move(data);
-}
-
-BufferedSerializer::BufferedSerializer(data_ptr_t data, idx_t size) : maximum_size(size), data(data) {
-	blob.size = 0;
-}
-
-void BufferedSerializer::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	if (blob.size + write_size >= maximum_size) {
-		do {
-			maximum_size *= 2;
-		} while (blob.size + write_size > maximum_size);
-		auto new_data = new data_t[maximum_size];
-		memcpy(new_data, data, blob.size);
-		data = new_data;
-		blob.data = unsafe_unique_array<data_t>(new_data);
-	}
-
-	memcpy(data + blob.size, buffer, write_size);
-	blob.size += write_size;
-}
-
-} // namespace duckdb

package/src/duckdb/src/common/serializer.cpp

@@ -1,24 +0,0 @@
-#include "duckdb/common/serializer.hpp"
-
-namespace duckdb {
-
-template <>
-string Deserializer::Read() {
-	uint32_t size = Read<uint32_t>();
-	if (size == 0) {
-		return string();
-	}
-	auto buffer = make_unsafe_uniq_array<data_t>(size);
-	ReadData(buffer.get(), size);
-	return string(const_char_ptr_cast(buffer.get()), size);
-}
-
-void Deserializer::ReadStringVector(vector<string> &list) {
-	uint32_t sz = Read<uint32_t>();
-	list.resize(sz);
-	for (idx_t i = 0; i < sz; i++) {
-		list[i] = Read<string>();
-	}
-}
-
-} // namespace duckdb

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

@@ -1,242 +0,0 @@
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
-
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-
-namespace duckdb {
-
-constexpr idx_t FixedSizeAllocator::BASE[];
-constexpr uint8_t FixedSizeAllocator::SHIFT[];
-
-FixedSizeAllocator::FixedSizeAllocator(const idx_t allocation_size, Allocator &allocator)
-    : allocation_size(allocation_size), total_allocations(0), allocator(allocator) {
-
-	// calculate how many allocations fit into one buffer
-
-	idx_t bits_per_value = sizeof(validity_t) * 8;
-	idx_t curr_alloc_size = 0;
-
-	bitmask_count = 0;
-	allocations_per_buffer = 0;
-
-	while (curr_alloc_size < BUFFER_ALLOC_SIZE) {
-		if (!bitmask_count || (bitmask_count * bits_per_value) % allocations_per_buffer == 0) {
-			bitmask_count++;
-			curr_alloc_size += sizeof(validity_t);
-		}
-
-		auto remaining_alloc_size = BUFFER_ALLOC_SIZE - curr_alloc_size;
-		auto remaining_allocations = MinValue(remaining_alloc_size / allocation_size, bits_per_value);
-
-		if (remaining_allocations == 0) {
-			break;
-		}
-
-		allocations_per_buffer += remaining_allocations;
-		curr_alloc_size += remaining_allocations * allocation_size;
-	}
-
-	allocation_offset = bitmask_count * sizeof(validity_t);
-}
-
-FixedSizeAllocator::~FixedSizeAllocator() {
-	for (auto &buffer : buffers) {
-		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
-	}
-}
-
-SwizzleablePointer FixedSizeAllocator::New() {
-
-	// no more free pointers
-	if (buffers_with_free_space.empty()) {
-
-		// add a new buffer
-		idx_t buffer_id = buffers.size();
-		D_ASSERT(buffer_id <= (uint32_t)DConstants::INVALID_INDEX);
-		auto buffer = allocator.AllocateData(BUFFER_ALLOC_SIZE);
-		buffers.emplace_back(buffer, 0);
-		buffers_with_free_space.insert(buffer_id);
-
-		// set the bitmask
-		ValidityMask mask(reinterpret_cast<validity_t *>(buffer));
-		mask.SetAllValid(allocations_per_buffer);
-	}
-
-	// return a pointer
-	D_ASSERT(!buffers_with_free_space.empty());
-	auto buffer_id = (uint32_t)*buffers_with_free_space.begin();
-
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[buffer_id].ptr);
-	ValidityMask mask(bitmask_ptr);
-	auto offset = GetOffset(mask, buffers[buffer_id].allocation_count);
-
-	buffers[buffer_id].allocation_count++;
-	total_allocations++;
-	if (buffers[buffer_id].allocation_count == allocations_per_buffer) {
-		buffers_with_free_space.erase(buffer_id);
-	}
-
-	return SwizzleablePointer(offset, buffer_id);
-}
-
-void FixedSizeAllocator::Free(const SwizzleablePointer ptr) {
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.buffer_id].ptr);
-	ValidityMask mask(bitmask_ptr);
-	D_ASSERT(!mask.RowIsValid(ptr.offset));
-	mask.SetValid(ptr.offset);
-	buffers_with_free_space.insert(ptr.buffer_id);
-
-	D_ASSERT(total_allocations > 0);
-	D_ASSERT(buffers[ptr.buffer_id].allocation_count > 0);
-	buffers[ptr.buffer_id].allocation_count--;
-	total_allocations--;
-}
-
-void FixedSizeAllocator::Reset() {
-
-	for (auto &buffer : buffers) {
-		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
-	}
-	buffers.clear();
-	buffers_with_free_space.clear();
-	total_allocations = 0;
-}
-
-void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
-
-	D_ASSERT(allocation_size == other.allocation_size);
-
-	// remember the buffer count and merge the buffers
-	idx_t buffer_count = buffers.size();
-	for (auto &buffer : other.buffers) {
-		buffers.push_back(buffer);
-	}
-	other.buffers.clear();
-
-	// merge the vectors containing all buffers with free space
-	for (auto &buffer_id : other.buffers_with_free_space) {
-		buffers_with_free_space.insert(buffer_id + buffer_count);
-	}
-	other.buffers_with_free_space.clear();
-
-	// add the total allocations
-	total_allocations += other.total_allocations;
-}
-
-bool FixedSizeAllocator::InitializeVacuum() {
-
-	if (total_allocations == 0) {
-		Reset();
-		return false;
-	}
-
-	auto total_available_allocations = allocations_per_buffer * buffers.size();
-	D_ASSERT(total_available_allocations >= total_allocations);
-	auto total_free_positions = total_available_allocations - total_allocations;
-
-	// vacuum_count buffers can be freed
-	auto vacuum_count = total_free_positions / allocations_per_buffer;
-
-	// calculate the vacuum threshold adaptively
-	D_ASSERT(vacuum_count < buffers.size());
-	idx_t memory_usage = GetMemoryUsage();
-	idx_t excess_memory_usage = vacuum_count * BUFFER_ALLOC_SIZE;
-	auto excess_percentage = (double)excess_memory_usage / (double)memory_usage;
-	auto threshold = (double)VACUUM_THRESHOLD / 100.0;
-	if (excess_percentage < threshold) {
-		return false;
-	}
-
-	min_vacuum_buffer_id = buffers.size() - vacuum_count;
-
-	// remove all invalid buffers from the available buffer list to ensure that we do not reuse them
-	auto it = buffers_with_free_space.begin();
-	while (it != buffers_with_free_space.end()) {
-		if (*it >= min_vacuum_buffer_id) {
-			it = buffers_with_free_space.erase(it);
-		} else {
-			it++;
-		}
-	}
-
-	return true;
-}
-
-void FixedSizeAllocator::FinalizeVacuum() {
-
-	// free all (now unused) buffers
-	while (min_vacuum_buffer_id < buffers.size()) {
-		allocator.FreeData(buffers.back().ptr, BUFFER_ALLOC_SIZE);
-		buffers.pop_back();
-	}
-}
-
-SwizzleablePointer FixedSizeAllocator::VacuumPointer(const SwizzleablePointer 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
-	total_allocations--;
-
-	memcpy(Get(new_ptr), Get(ptr), allocation_size);
-	return new_ptr;
-}
-
-void FixedSizeAllocator::Verify() const {
-#ifdef DEBUG
-	auto total_available_allocations = allocations_per_buffer * buffers.size();
-	D_ASSERT(total_available_allocations >= total_allocations);
-	D_ASSERT(buffers.size() >= buffers_with_free_space.size());
-#endif
-}
-
-uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t allocation_count) {
-
-	auto data = mask.GetData();
-
-	// fills up a buffer sequentially before searching for free bits
-	if (mask.RowIsValid(allocation_count)) {
-		mask.SetInvalid(allocation_count);
-		return allocation_count;
-	}
-
-	// get an entry with free bits
-	for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) {
-		if (data[entry_idx] != 0) {
-
-			// 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 of FixedSizeAllocator");
-}
-
-} // namespace duckdb