duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

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

@@ -87,7 +87,7 @@ PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
                                                    const vector<unique_ptr<BaseStatistics>> &partition_stats,
                                                    idx_t estimated_cardinality)
     : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
-      payload_types(payload_types), memory_per_thread(0), count(0) {
+      fixed_bits(0), payload_types(payload_types), memory_per_thread(0), count(0) {
 
 	GenerateOrderings(partitions, orders, partition_bys, order_bys, partition_stats);
 
@@ -102,9 +102,19 @@ PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
 	}
 }
 
+void PartitionGlobalSinkState::SyncPartitioning(const PartitionGlobalSinkState &other) {
+	fixed_bits = other.grouping_data ? other.grouping_data->GetRadixBits() : 0;
+
+	const auto old_bits = grouping_data ? grouping_data->GetRadixBits() : 0;
+	if (fixed_bits != old_bits) {
+		const auto hash_col_idx = payload_types.size();
+		grouping_data = make_uniq<RadixPartitionedColumnData>(context, grouping_types, fixed_bits, hash_col_idx);
+	}
+}
+
 void PartitionGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
 	//	Have we started to combine? Then just live with it.
-	if (grouping_data && !grouping_data->GetPartitions().empty()) {
+	if (fixed_bits || (grouping_data && !grouping_data->GetPartitions().empty())) {
 		return;
 	}
 	//	Is the average partition size too large?
@@ -186,9 +196,7 @@ void PartitionGlobalSinkState::CombineLocalPartition(GroupingPartition &local_pa
 	grouping_data->Combine(*local_partition);
 }
 
-void PartitionGlobalSinkState::BuildSortState(ColumnDataCollection &group_data, PartitionGlobalHashGroup &hash_group) {
-	auto &global_sort = *hash_group.global_sort;
-
+void PartitionGlobalSinkState::BuildSortState(ColumnDataCollection &group_data, GlobalSortState &global_sort) const {
 	//	 Set up the sort expression computation.
 	vector<LogicalType> sort_types;
 	ExpressionExecutor executor(context);
@@ -234,6 +242,10 @@ void PartitionGlobalSinkState::BuildSortState(ColumnDataCollection &group_data,
 	}
 
 	global_sort.AddLocalState(local_sort);
+}
+
+void PartitionGlobalSinkState::BuildSortState(ColumnDataCollection &group_data, PartitionGlobalHashGroup &hash_group) {
+	BuildSortState(group_data, *hash_group.global_sort);
 
 	hash_group.count += group_data.Count();
 }
@@ -482,18 +494,29 @@ public:
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
 
 private:
+	struct ExecutorCallback : public PartitionGlobalMergeStates::Callback {
+		explicit ExecutorCallback(Executor &executor) : executor(executor) {
+		}
+
+		bool HasError() const override {
+			return executor.HasError();
+		}
+
+		Executor &executor;
+	};
+
 	shared_ptr<Event> event;
 	PartitionLocalMergeState local_state;
 	PartitionGlobalMergeStates &hash_groups;
 };
 
-TaskExecutionResult PartitionMergeTask::ExecuteTask(TaskExecutionMode mode) {
+bool PartitionGlobalMergeStates::ExecuteTask(PartitionLocalMergeState &local_state, Callback &callback) {
 	// Loop until all hash groups are done
 	size_t sorted = 0;
-	while (sorted < hash_groups.states.size()) {
+	while (sorted < states.size()) {
 		// First check if there is an unfinished task for this thread
-		if (executor.HasError()) {
-			return TaskExecutionResult::TASK_ERROR;
+		if (callback.HasError()) {
+			return false;
 		}
 		if (!local_state.TaskFinished()) {
 			local_state.ExecuteTask();
@@ -501,8 +524,8 @@ TaskExecutionResult PartitionMergeTask::ExecuteTask(TaskExecutionMode mode) {
 		}
 
 		// Thread is done with its assigned task, try to fetch new work
-		for (auto group = sorted; group < hash_groups.states.size(); ++group) {
-			auto &global_state = hash_groups.states[group];
+		for (auto group = sorted; group < states.size(); ++group) {
+			auto &global_state = states[group];
 			if (global_state->IsSorted()) {
 				// This hash group is done
 				// Update the high water mark of densely completed groups
@@ -543,6 +566,16 @@ TaskExecutionResult PartitionMergeTask::ExecuteTask(TaskExecutionMode mode) {
 		}
 	}
 
+	return true;
+}
+
+TaskExecutionResult PartitionMergeTask::ExecuteTask(TaskExecutionMode mode) {
+	ExecutorCallback callback(executor);
+
+	if (!hash_groups.ExecuteTask(local_state, callback)) {
+		return TaskExecutionResult::TASK_ERROR;
+	}
+
 	event->FinishTask();
 	return TaskExecutionResult::TASK_FINISHED;
 }

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

@@ -1,11 +1,14 @@
 #include "duckdb/common/types/batched_data_collection.hpp"
+
+#include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
-BatchedDataCollection::BatchedDataCollection(vector<LogicalType> types_p) : types(std::move(types_p)) {
+BatchedDataCollection::BatchedDataCollection(ClientContext &context_p, vector<LogicalType> types_p,
+                                             bool buffer_managed_p)
+    : context(context_p), types(std::move(types_p)), buffer_managed(buffer_managed_p) {
 }
 
 void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
@@ -20,6 +23,8 @@ void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
 		unique_ptr<ColumnDataCollection> new_collection;
 		if (last_collection.collection) {
 			new_collection = make_uniq<ColumnDataCollection>(*last_collection.collection);
+		} else if (buffer_managed) {
+			new_collection = make_uniq<ColumnDataCollection>(BufferManager::GetBufferManager(context), types);
 		} else {
 			new_collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 		}

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

@@ -1,4 +1,6 @@
+#include "duckdb/common/assert.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/string_type.hpp"
 
@@ -34,6 +36,13 @@ static inline idx_t GetBitSize(const string_t &str) {
 	return str_len;
 }
 
+uint8_t Bit::GetFirstByte(const string_t &str) {
+	D_ASSERT(str.GetSize() > 1);
+
+	auto data = const_data_ptr_cast(str.GetData());
+	return data[1] & ((1 << (8 - data[0])) - 1);
+}
+
 void Bit::Finalize(string_t &str) {
 	// bit strings require all padding bits to be set to 1
 	// this method sets all padding bits to 1
@@ -146,6 +155,48 @@ string Bit::ToBit(string_t str) {
 	return output_str.GetString();
 }
 
+void Bit::BlobToBit(string_t blob, string_t &output_str) {
+	auto data = const_data_ptr_cast(blob.GetData());
+	auto output = output_str.GetDataWriteable();
+	idx_t size = blob.GetSize();
+
+	*output = 0; // No padding
+	memcpy(output + 1, data, size);
+}
+
+string Bit::BlobToBit(string_t blob) {
+	auto buffer = make_unsafe_uniq_array<char>(blob.GetSize() + 1);
+	string_t output_str(buffer.get(), blob.GetSize() + 1);
+	Bit::BlobToBit(blob, output_str);
+	return output_str.GetString();
+}
+
+void Bit::BitToBlob(string_t bit, string_t &output_blob) {
+	D_ASSERT(bit.GetSize() == output_blob.GetSize() + 1);
+
+	auto data = const_data_ptr_cast(bit.GetData());
+	auto output = output_blob.GetDataWriteable();
+	idx_t size = output_blob.GetSize();
+
+	output[0] = GetFirstByte(bit);
+	if (size > 2) {
+		++output;
+		// First byte in bitstring contains amount of padded bits,
+		// second byte in bitstring is the padded byte,
+		// therefore the rest of the data starts at data + 2 (third byte)
+		memcpy(output, data + 2, size - 1);
+	}
+}
+
+string Bit::BitToBlob(string_t bit) {
+	D_ASSERT(bit.GetSize() > 1);
+
+	auto buffer = make_unsafe_uniq_array<char>(bit.GetSize() - 1);
+	string_t output_str(buffer.get(), bit.GetSize() - 1);
+	Bit::BitToBlob(bit, output_str);
+	return output_str.GetString();
+}
+
 // **** scalar functions ****
 void Bit::BitString(const string_t &input, const idx_t &bit_length, string_t &result) {
 	char *res_buf = result.GetDataWriteable();

package/src/duckdb/src/common/types/column/column_data_allocator.cpp

@@ -1,8 +1,8 @@
 #include "duckdb/common/types/column/column_data_allocator.hpp"
 
 #include "duckdb/common/types/column/column_data_collection_segment.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
 
@@ -19,6 +19,7 @@ ColumnDataAllocator::ColumnDataAllocator(ClientContext &context, ColumnDataAlloc
     : type(allocator_type) {
 	switch (type) {
 	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
+	case ColumnDataAllocatorType::HYBRID:
 		alloc.buffer_manager = &BufferManager::GetBufferManager(context);
 		break;
 	case ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR:
@@ -33,6 +34,7 @@ ColumnDataAllocator::ColumnDataAllocator(ColumnDataAllocator &other) {
 	type = other.GetType();
 	switch (type) {
 	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
+	case ColumnDataAllocatorType::HYBRID:
 		alloc.allocator = other.alloc.allocator;
 		break;
 	case ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR:
@@ -44,7 +46,7 @@ ColumnDataAllocator::ColumnDataAllocator(ColumnDataAllocator &other) {
 }
 
 BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {
-	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
+	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
 	shared_ptr<BlockHandle> handle;
 	if (shared) {
 		// we only need to grab the lock when accessing the vector, because vector access is not thread-safe:
@@ -58,7 +60,7 @@ BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {
 }
 
 BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
-	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR);
+	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
 	auto block_size = MaxValue<idx_t>(size, Storage::BLOCK_SIZE);
 	BlockMetaData data;
 	data.size = 0;
@@ -136,6 +138,7 @@ void ColumnDataAllocator::AllocateData(idx_t size, uint32_t &block_id, uint32_t
                                        ChunkManagementState *chunk_state) {
 	switch (type) {
 	case ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR:
+	case ColumnDataAllocatorType::HYBRID:
 		if (shared) {
 			lock_guard<mutex> guard(lock);
 			AllocateBuffer(size, block_id, offset, chunk_state);
@@ -174,8 +177,8 @@ data_ptr_t ColumnDataAllocator::GetDataPointer(ChunkManagementState &state, uint
 	return state.handles[block_id].Ptr() + offset;
 }
 
-void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector &result, uint16_t v_offset,
-                                            uint16_t count, uint32_t block_id, uint32_t offset) {
+void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector &result, idx_t v_offset, uint16_t count,
+                                            uint32_t block_id, uint32_t offset) {
 	D_ASSERT(result.GetType().InternalType() == PhysicalType::VARCHAR);
 	lock_guard<mutex> guard(lock);
 
@@ -225,7 +228,7 @@ Allocator &ColumnDataAllocator::GetAllocator() {
 }
 
 void ColumnDataAllocator::InitializeChunkState(ChunkManagementState &state, ChunkMetaData &chunk) {
-	if (type != ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
+	if (type != ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR && type != ColumnDataAllocatorType::HYBRID) {
 		// nothing to pin
 		return;
 	}

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -333,7 +333,7 @@ struct StandardValueCopy : public BaseValueCopy<T> {
 
 struct StringValueCopy : public BaseValueCopy<string_t> {
 	static string_t Operation(ColumnDataMetaData &meta_data, string_t input) {
-		return input.IsInlined() ? input : meta_data.segment.heap.AddBlob(input);
+		return input.IsInlined() ? input : meta_data.segment.heap->AddBlob(input);
 	}
 };
 
@@ -423,7 +423,8 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
                               idx_t offset, idx_t copy_count) {
 
 	const auto &allocator_type = meta_data.segment.allocator->GetType();
-	if (allocator_type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
+	if (allocator_type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR ||
+	    allocator_type == ColumnDataAllocatorType::HYBRID) {
 		// strings cannot be spilled to disk - use StringHeap
 		TemplatedColumnDataCopy<StringValueCopy>(meta_data, source_data, source, offset, copy_count);
 		return;
@@ -930,6 +931,7 @@ void ColumnDataCollection::Verify() {
 #endif
 }
 
+// LCOV_EXCL_START
 string ColumnDataCollection::ToString() const {
 	DataChunk chunk;
 	InitializeScanChunk(chunk);
@@ -950,6 +952,7 @@ string ColumnDataCollection::ToString() const {
 
 	return result;
 }
+// LCOV_EXCL_STOP
 
 void ColumnDataCollection::Print() const {
 	Printer::Print(ToString());
@@ -1030,6 +1033,18 @@ bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const
 	return true;
 }
 
+vector<shared_ptr<StringHeap>> ColumnDataCollection::GetHeapReferences() {
+	vector<shared_ptr<StringHeap>> result(segments.size(), nullptr);
+	for (idx_t segment_idx = 0; segment_idx < segments.size(); segment_idx++) {
+		result[segment_idx] = segments[segment_idx]->heap;
+	}
+	return result;
+}
+
+ColumnDataAllocatorType ColumnDataCollection::GetAllocatorType() const {
+	return allocator->GetType();
+}
+
 const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::GetSegments() const {
 	return segments;
 }

package/src/duckdb/src/common/types/column/column_data_collection_segment.cpp

@@ -6,7 +6,8 @@ namespace duckdb {
 
 ColumnDataCollectionSegment::ColumnDataCollectionSegment(shared_ptr<ColumnDataAllocator> allocator_p,
                                                          vector<LogicalType> types_p)
-    : allocator(std::move(allocator_p)), types(std::move(types_p)), count(0), heap(allocator->GetAllocator()) {
+    : allocator(std::move(allocator_p)), types(std::move(types_p)), count(0),
+      heap(make_shared<StringHeap>(allocator->GetAllocator())) {
 }
 
 idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {
@@ -26,7 +27,8 @@ VectorDataIndex ColumnDataCollectionSegment::AllocateVectorInternal(const Logica
 	auto type_size = internal_type == PhysicalType::STRUCT ? 0 : GetTypeIdSize(internal_type);
 	allocator->AllocateData(GetDataSize(type_size) + ValidityMask::STANDARD_MASK_SIZE, meta_data.block_id,
 	                        meta_data.offset, chunk_state);
-	if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
+	if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR ||
+	    allocator->GetType() == ColumnDataAllocatorType::HYBRID) {
 		chunk_meta.block_ids.insert(meta_data.block_id);
 	}
 
@@ -203,10 +205,17 @@ idx_t ColumnDataCollectionSegment::ReadVector(ChunkManagementState &state, Vecto
 		}
 	} else if (internal_type == PhysicalType::VARCHAR) {
 		if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
-			for (auto &swizzle_segment : vdata.swizzle_data) {
-				auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
-				allocator->UnswizzlePointers(state, result, swizzle_segment.offset, swizzle_segment.count,
-				                             string_heap_segment.block_id, string_heap_segment.offset);
+			auto next_index = vector_index;
+			idx_t offset = 0;
+			while (next_index.IsValid()) {
+				auto &current_vdata = GetVectorData(next_index);
+				for (auto &swizzle_segment : current_vdata.swizzle_data) {
+					auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
+					allocator->UnswizzlePointers(state, result, offset + swizzle_segment.offset, swizzle_segment.count,
+					                             string_heap_segment.block_id, string_heap_segment.offset);
+				}
+				offset += current_vdata.count;
+				next_index = current_vdata.next_data;
 			}
 		}
 		if (state.properties == ColumnDataScanProperties::DISALLOW_ZERO_COPY) {

package/src/duckdb/src/common/types/column/partitioned_column_data.cpp

@@ -32,13 +32,13 @@ PartitionedColumnData::~PartitionedColumnData() {
 
 void PartitionedColumnData::InitializeAppendState(PartitionedColumnDataAppendState &state) const {
 	state.partition_sel.Initialize();
-	state.slice_chunk.Initialize(context, types);
+	state.slice_chunk.Initialize(BufferAllocator::Get(context), types);
 	InitializeAppendStateInternal(state);
 }
 
 unique_ptr<DataChunk> PartitionedColumnData::CreatePartitionBuffer() const {
 	auto result = make_uniq<DataChunk>();
-	result->Initialize(BufferManager::GetBufferManager(context).GetBufferAllocator(), types, BufferSize());
+	result->Initialize(BufferAllocator::Get(context), types, BufferSize());
 	return result;
 }
 

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

@@ -309,7 +309,7 @@ void DataChunk::Hash(Vector &result) {
 
 void DataChunk::Hash(vector<idx_t> &column_ids, Vector &result) {
 	D_ASSERT(result.GetType().id() == LogicalType::HASH);
-	D_ASSERT(column_ids.size() > 0);
+	D_ASSERT(!column_ids.empty());
 
 	VectorOperations::Hash(data[column_ids[0]], result, size());
 	for (idx_t i = 1; i < column_ids.size(); i++) {
@@ -327,7 +327,7 @@ void DataChunk::Verify() {
 #endif
 }
 
-void DataChunk::Print() {
+void DataChunk::Print() const {
 	Printer::Print(ToString());
 }
 

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

@@ -441,6 +441,15 @@ int64_t Date::EpochMicroseconds(date_t date) {
 	return result;
 }
 
+int64_t Date::EpochMilliseconds(date_t date) {
+	int64_t result;
+	const auto MILLIS_PER_DAY = Interval::MICROS_PER_DAY / Interval::MICROS_PER_MSEC;
+	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, MILLIS_PER_DAY, result)) {
+		throw ConversionException("Could not convert DATE (%s) to milliseconds", Date::ToString(date));
+	}
+	return result;
+}
+
 int32_t Date::ExtractYear(date_t d, int32_t *last_year) {
 	auto n = d.days;
 	// cached look up: check if year of this date is the same as the last one we looked up

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

@@ -12,8 +12,8 @@ static idx_t GetAllocationSize(uint16_t capacity) {
 }
 
 template <class T>
-static data_ptr_t AllocatePrimitiveData(Allocator &allocator, uint16_t capacity) {
-	return allocator.AllocateData(GetAllocationSize<T>(capacity));
+static data_ptr_t AllocatePrimitiveData(ArenaAllocator &allocator, uint16_t capacity) {
+	return allocator.Allocate(GetAllocationSize<T>(capacity));
 }
 
 template <class T>
@@ -34,8 +34,8 @@ static idx_t GetAllocationSizeList(uint16_t capacity) {
 	return AlignValue(sizeof(ListSegment) + capacity * (sizeof(bool) + sizeof(uint64_t)) + sizeof(LinkedList));
 }
 
-static data_ptr_t AllocateListData(Allocator &allocator, uint16_t capacity) {
-	return allocator.AllocateData(GetAllocationSizeList(capacity));
+static data_ptr_t AllocateListData(ArenaAllocator &allocator, uint16_t capacity) {
+	return allocator.Allocate(GetAllocationSizeList(capacity));
 }
 
 static uint64_t *GetListLengthData(ListSegment *segment) {
@@ -65,8 +65,8 @@ static idx_t GetAllocationSizeStruct(uint16_t capacity, idx_t child_count) {
 	return AlignValue(sizeof(ListSegment) + capacity * sizeof(bool) + child_count * sizeof(ListSegment *));
 }
 
-static data_ptr_t AllocateStructData(Allocator &allocator, uint16_t capacity, idx_t child_count) {
-	return allocator.AllocateData(GetAllocationSizeStruct(capacity, child_count));
+static data_ptr_t AllocateStructData(ArenaAllocator &allocator, uint16_t capacity, idx_t child_count) {
+	return allocator.Allocate(GetAllocationSizeStruct(capacity, child_count));
 }
 
 static ListSegment **GetStructData(ListSegment *segment) {
@@ -98,20 +98,8 @@ static uint16_t GetCapacityForNewSegment(uint16_t capacity) {
 //===--------------------------------------------------------------------===//
 // Create & Destroy
 //===--------------------------------------------------------------------===//
-static void DestroyLinkedList(const ListSegmentFunctions &functions, Allocator &allocator, LinkedList &list) {
-	auto segment = list.first_segment;
-	while (segment) {
-		auto next_segment = segment->next;
-		functions.destroy(functions, segment, allocator);
-		segment = next_segment;
-	}
-	list.first_segment = nullptr;
-	list.last_segment = nullptr;
-	list.total_capacity = 0;
-}
-
 template <class T>
-static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, Allocator &allocator, uint16_t capacity) {
+static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
 	// allocate data and set the header
 	auto segment = (ListSegment *)AllocatePrimitiveData<T>(allocator, capacity);
 	segment->capacity = capacity;
@@ -120,13 +108,7 @@ static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, Allocat
 	return segment;
 }
 
-template <class T>
-void DestroyPrimitiveSegment(const ListSegmentFunctions &, ListSegment *segment, Allocator &allocator) {
-	D_ASSERT(segment);
-	allocator.FreeData(data_ptr_cast(segment), GetAllocationSize<T>(segment->capacity));
-}
-
-static ListSegment *CreateListSegment(const ListSegmentFunctions &, Allocator &allocator, uint16_t capacity) {
+static ListSegment *CreateListSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
 	// allocate data and set the header
 	auto segment = reinterpret_cast<ListSegment *>(AllocateListData(allocator, capacity));
 	segment->capacity = capacity;
@@ -141,16 +123,7 @@ static ListSegment *CreateListSegment(const ListSegmentFunctions &, Allocator &a
 	return segment;
 }
 
-void DestroyListSegment(const ListSegmentFunctions &functions, ListSegment *segment, Allocator &allocator) {
-	// destroy the child list
-	auto linked_child_list = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
-	DestroyLinkedList(functions.child_functions[0], allocator, linked_child_list);
-
-	// destroy the list segment itself
-	allocator.FreeData(data_ptr_cast(segment), GetAllocationSizeList(segment->capacity));
-}
-
-static ListSegment *CreateStructSegment(const ListSegmentFunctions &functions, Allocator &allocator,
+static ListSegment *CreateStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
                                         uint16_t capacity) {
 	// allocate data and set header
 	auto segment =
@@ -170,21 +143,8 @@ static ListSegment *CreateStructSegment(const ListSegmentFunctions &functions, A
 	return segment;
 }
 
-void DestroyStructSegment(const ListSegmentFunctions &functions, ListSegment *segment, Allocator &allocator) {
-	// destroy the child entries
-	auto child_segments = GetStructData(segment);
-	for (idx_t i = 0; i < functions.child_functions.size(); i++) {
-		auto child_function = functions.child_functions[i];
-		auto child_segment = Load<ListSegment *>(data_ptr_cast(child_segments + i));
-		child_function.destroy(child_function, child_segment, allocator);
-	}
-
-	// destroy the struct segment itself
-	allocator.FreeData(data_ptr_cast(segment),
-	                   GetAllocationSizeStruct(segment->capacity, functions.child_functions.size()));
-}
-
-static ListSegment *GetSegment(const ListSegmentFunctions &functions, Allocator &allocator, LinkedList &linked_list) {
+static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
+                               LinkedList &linked_list) {
 	ListSegment *segment;
 
 	// determine segment
@@ -214,7 +174,7 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, Allocator
 // Append
 //===--------------------------------------------------------------------===//
 template <class T>
-static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, Allocator &allocator,
+static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
                                         ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
 
 	// get the vector data and the source index of the entry that we want to write
@@ -232,8 +192,8 @@ static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, A
 	}
 }
 
-static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, Allocator &allocator, ListSegment *segment,
-                                      Vector &input, idx_t &entry_idx, idx_t &count) {
+static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
+                                      ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
 
 	// get the vector data and the source index of the entry that we want to write
 	auto input_data = FlatVector::GetData<string_t>(input);
@@ -275,8 +235,8 @@ static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, All
 	Store<LinkedList>(child_segments, data_ptr_cast(GetListChildData(segment)));
 }
 
-static void WriteDataToListSegment(const ListSegmentFunctions &functions, Allocator &allocator, ListSegment *segment,
-                                   Vector &input, idx_t &entry_idx, idx_t &count) {
+static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
+                                   ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
 
 	// get the vector data and the source index of the entry that we want to write
 	auto input_data = FlatVector::GetData<list_entry_t>(input);
@@ -315,8 +275,8 @@ static void WriteDataToListSegment(const ListSegmentFunctions &functions, Alloca
 	Store<uint64_t>(list_length, data_ptr_cast(list_length_data + segment->count));
 }
 
-static void WriteDataToStructSegment(const ListSegmentFunctions &functions, Allocator &allocator, ListSegment *segment,
-                                     Vector &input, idx_t &entry_idx, idx_t &count) {
+static void WriteDataToStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
+                                     ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
@@ -338,8 +298,8 @@ static void WriteDataToStructSegment(const ListSegmentFunctions &functions, Allo
 	}
 }
 
-void ListSegmentFunctions::AppendRow(Allocator &allocator, LinkedList &linked_list, Vector &input, idx_t &entry_idx,
-                                     idx_t &count) const {
+void ListSegmentFunctions::AppendRow(ArenaAllocator &allocator, LinkedList &linked_list, Vector &input,
+                                     idx_t &entry_idx, idx_t &count) const {
 
 	D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &write_data_to_segment = *this;
@@ -503,7 +463,7 @@ void ListSegmentFunctions::BuildListVector(const LinkedList &linked_list, Vector
 //===--------------------------------------------------------------------===//
 template <class T>
 static ListSegment *CopyDataFromPrimitiveSegment(const ListSegmentFunctions &, const ListSegment *source,
-                                                 Allocator &allocator) {
+                                                 ArenaAllocator &allocator) {
 
 	auto target = (ListSegment *)AllocatePrimitiveData<T>(allocator, source->capacity);
 	memcpy(target, source, sizeof(ListSegment) + source->capacity * (sizeof(bool) + sizeof(T)));
@@ -512,7 +472,7 @@ static ListSegment *CopyDataFromPrimitiveSegment(const ListSegmentFunctions &, c
 }
 
 static ListSegment *CopyDataFromListSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                            Allocator &allocator) {
+                                            ArenaAllocator &allocator) {
 
 	// create an empty linked list for the child vector of target
 	auto source_linked_child_list = Load<LinkedList>(const_data_ptr_cast(GetListChildData(source)));
@@ -538,7 +498,7 @@ static ListSegment *CopyDataFromListSegment(const ListSegmentFunctions &function
 }
 
 static ListSegment *CopyDataFromStructSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                              Allocator &allocator) {
+                                              ArenaAllocator &allocator) {
 
 	auto source_child_count = functions.child_functions.size();
 	auto target = reinterpret_cast<ListSegment *>(AllocateStructData(allocator, source->capacity, source_child_count));
@@ -560,7 +520,7 @@ static ListSegment *CopyDataFromStructSegment(const ListSegmentFunctions &functi
 }
 
 void ListSegmentFunctions::CopyLinkedList(const LinkedList &source_list, LinkedList &target_list,
-                                          Allocator &allocator) const {
+                                          ArenaAllocator &allocator) const {
 	auto &copy_data_from_segment = *this;
 	auto source_segment = source_list.first_segment;
 
@@ -578,12 +538,6 @@ void ListSegmentFunctions::CopyLinkedList(const LinkedList &source_list, LinkedL
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Destroy
-//===--------------------------------------------------------------------===//
-void ListSegmentFunctions::Destroy(Allocator &allocator, LinkedList &linked_list) const {
-	DestroyLinkedList(*this, allocator, linked_list);
-}
 //===--------------------------------------------------------------------===//
 // Functions
 //===--------------------------------------------------------------------===//
@@ -593,7 +547,6 @@ void SegmentPrimitiveFunction(ListSegmentFunctions &functions) {
 	functions.write_data = WriteDataToPrimitiveSegment<T>;
 	functions.read_data = ReadDataFromPrimitiveSegment<T>;
 	functions.copy_data = CopyDataFromPrimitiveSegment<T>;
-	functions.destroy = DestroyPrimitiveSegment<T>;
 }
 
 void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type) {
@@ -645,7 +598,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.write_data = WriteDataToVarcharSegment;
 		functions.read_data = ReadDataFromVarcharSegment;
 		functions.copy_data = CopyDataFromListSegment;
-		functions.destroy = DestroyListSegment;
 
 		functions.child_functions.emplace_back();
 		SegmentPrimitiveFunction<char>(functions.child_functions.back());
@@ -656,7 +608,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.write_data = WriteDataToListSegment;
 		functions.read_data = ReadDataFromListSegment;
 		functions.copy_data = CopyDataFromListSegment;
-		functions.destroy = DestroyListSegment;
 
 		// recurse
 		functions.child_functions.emplace_back();
@@ -668,7 +619,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.write_data = WriteDataToStructSegment;
 		functions.read_data = ReadDataFromStructSegment;
 		functions.copy_data = CopyDataFromStructSegment;
-		functions.destroy = DestroyStructSegment;
 
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);