duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/algorithm.hpp"
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/common/types/value.hpp"
@@ -763,6 +764,45 @@ hugeint_t &hugeint_t::operator^=(const hugeint_t &rhs) {
 	return *this;
 }
 
+bool hugeint_t::operator!() const {
+	return *this == 0;
+}
+
+hugeint_t::operator bool() const {
+	return *this != 0;
+}
+
+template <class T>
+static T NarrowCast(const hugeint_t &input) {
+	// NarrowCast is supposed to truncate (take lower)
+	return static_cast<T>(input.lower);
+}
+
+hugeint_t::operator uint8_t() const {
+	return NarrowCast<uint8_t>(*this);
+}
+hugeint_t::operator uint16_t() const {
+	return NarrowCast<uint16_t>(*this);
+}
+hugeint_t::operator uint32_t() const {
+	return NarrowCast<uint32_t>(*this);
+}
+hugeint_t::operator uint64_t() const {
+	return NarrowCast<uint64_t>(*this);
+}
+hugeint_t::operator int8_t() const {
+	return NarrowCast<int8_t>(*this);
+}
+hugeint_t::operator int16_t() const {
+	return NarrowCast<int16_t>(*this);
+}
+hugeint_t::operator int32_t() const {
+	return NarrowCast<int32_t>(*this);
+}
+hugeint_t::operator int64_t() const {
+	return NarrowCast<int64_t>(*this);
+}
+
 string hugeint_t::ToString() const {
 	return Hugeint::ToString(*this);
 }

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

@@ -116,6 +116,9 @@ interval_parse_time : {
 	}
 	result.micros += time.micros;
 	found_any = true;
+	if (negative) {
+		result.micros = -result.micros;
+	}
 	goto end_of_string;
 }
 interval_parse_identifier:

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) {
@@ -96,22 +96,10 @@ static uint16_t GetCapacityForNewSegment(uint16_t capacity) {
 }
 
 //===--------------------------------------------------------------------===//
-// Create & Destroy
+// Create
 //===--------------------------------------------------------------------===//
-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,56 +174,55 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, Allocator
 // Append
 //===--------------------------------------------------------------------===//
 template <class T>
-static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, Allocator &allocator,
-                                        ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &, ListSegment *segment,
+                                        RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
 
-	// get the vector data and the source index of the entry that we want to write
-	auto input_data = FlatVector::GetData(input);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// write value
-	if (!is_null) {
-		auto data = GetPrimitiveData<T>(segment);
-		Store<T>(((T *)input_data)[entry_idx], data_ptr_cast(data + segment->count));
+	if (valid) {
+		auto segment_data = GetPrimitiveData<T>(segment);
+		auto input_data_ptr = UnifiedVectorFormat::GetData<T>(input_data.unified);
+		Store<T>(input_data_ptr[sel_entry_idx], data_ptr_cast(segment_data + segment->count));
 	}
 }
 
-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, RecursiveUnifiedVectorFormat &input_data,
+                                      idx_t &entry_idx) {
 
-	// get the vector data and the source index of the entry that we want to write
-	auto input_data = FlatVector::GetData<string_t>(input);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// set the length of this string
 	auto str_length_data = GetListLengthData(segment);
 	uint64_t str_length = 0;
 
 	// get the string
-	string_t str_t;
-	if (!is_null) {
-		str_t = input_data[entry_idx];
-		str_length = str_t.GetSize();
+	string_t str_entry;
+	if (valid) {
+		str_entry = UnifiedVectorFormat::GetData<string_t>(input_data.unified)[sel_entry_idx];
+		str_length = str_entry.GetSize();
 	}
 
 	// we can reconstruct the offset from the length
 	Store<uint64_t>(str_length, data_ptr_cast(str_length_data + segment->count));
-
-	if (is_null) {
+	if (!valid) {
 		return;
 	}
 
 	// write the characters to the linked list of child segments
 	auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
-	for (char &c : str_t.GetString()) {
+	for (char &c : str_entry.GetString()) {
 		auto child_segment = GetSegment(functions.child_functions.back(), allocator, child_segments);
 		auto data = GetPrimitiveData<char>(child_segment);
 		data[child_segment->count] = c;
@@ -275,38 +234,32 @@ 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, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
 
-	// 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);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// set the length of this list
 	auto list_length_data = GetListLengthData(segment);
 	uint64_t list_length = 0;
 
-	if (!is_null) {
+	if (valid) {
 		// get list entry information
-		auto list_entries = input_data;
-		const auto &list_entry = list_entries[entry_idx];
+		const auto &list_entry = UnifiedVectorFormat::GetData<list_entry_t>(input_data.unified)[sel_entry_idx];
 		list_length = list_entry.length;
 
-		// get the child vector and its data
-		auto lists_size = ListVector::GetListSize(input);
-		auto &child_vector = ListVector::GetEntry(input);
-
 		// loop over the child vector entries and recurse on them
 		auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
 		D_ASSERT(functions.child_functions.size() == 1);
 		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
 			auto source_idx_child = list_entry.offset + child_idx;
-			functions.child_functions[0].AppendRow(allocator, child_segments, child_vector, source_idx_child,
-			                                       lists_size);
+			functions.child_functions[0].AppendRow(allocator, child_segments, input_data.children.back(),
+			                                       source_idx_child);
 		}
 		// store the updated linked list
 		Store<LinkedList>(child_segments, data_ptr_cast(GetListChildData(segment)));
@@ -315,36 +268,35 @@ 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, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
+
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// write value
-	auto &children = StructVector::GetEntries(input);
-	D_ASSERT(children.size() == functions.child_functions.size());
+	D_ASSERT(input_data.children.size() == functions.child_functions.size());
 	auto child_list = GetStructData(segment);
 
 	// write the data of each of the children of the struct
-	for (idx_t child_count = 0; child_count < children.size(); child_count++) {
-		auto child_list_segment = Load<ListSegment *>(data_ptr_cast(child_list + child_count));
-		auto &child_function = functions.child_functions[child_count];
-		child_function.write_data(child_function, allocator, child_list_segment, *children[child_count], entry_idx,
-		                          count);
+	for (idx_t i = 0; i < input_data.children.size(); i++) {
+		auto child_list_segment = Load<ListSegment *>(data_ptr_cast(child_list + i));
+		auto &child_function = functions.child_functions[i];
+		child_function.write_data(child_function, allocator, child_list_segment, input_data.children[i], entry_idx);
 		child_list_segment->count++;
 	}
 }
 
-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,
+                                     RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) const {
 
-	D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &write_data_to_segment = *this;
 	auto segment = GetSegment(write_data_to_segment, allocator, linked_list);
-	write_data_to_segment.write_data(write_data_to_segment, allocator, segment, input, entry_idx, count);
+	write_data_to_segment.write_data(write_data_to_segment, allocator, segment, input_data, entry_idx);
 
 	linked_list.total_capacity++;
 	segment->count++;
@@ -498,92 +450,6 @@ void ListSegmentFunctions::BuildListVector(const LinkedList &linked_list, Vector
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Copy
-//===--------------------------------------------------------------------===//
-template <class T>
-static ListSegment *CopyDataFromPrimitiveSegment(const ListSegmentFunctions &, const ListSegment *source,
-                                                 Allocator &allocator) {
-
-	auto target = (ListSegment *)AllocatePrimitiveData<T>(allocator, source->capacity);
-	memcpy(target, source, sizeof(ListSegment) + source->capacity * (sizeof(bool) + sizeof(T)));
-	target->next = nullptr;
-	return target;
-}
-
-static ListSegment *CopyDataFromListSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                            Allocator &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)));
-
-	// create the segment
-	auto target = reinterpret_cast<ListSegment *>(AllocateListData(allocator, source->capacity));
-	memcpy(target, source,
-	       sizeof(ListSegment) + source->capacity * (sizeof(bool) + sizeof(uint64_t)) + sizeof(LinkedList));
-	target->next = nullptr;
-
-	auto target_linked_list = GetListChildData(target);
-	LinkedList linked_list(source_linked_child_list.total_capacity, nullptr, nullptr);
-	Store<LinkedList>(linked_list, data_ptr_cast(target_linked_list));
-
-	// recurse to copy the linked child list
-	auto target_linked_child_list = Load<LinkedList>(data_ptr_cast(GetListChildData(target)));
-	D_ASSERT(functions.child_functions.size() == 1);
-	functions.child_functions[0].CopyLinkedList(source_linked_child_list, target_linked_child_list, allocator);
-
-	// store the updated linked list
-	Store<LinkedList>(target_linked_child_list, data_ptr_cast(GetListChildData(target)));
-	return target;
-}
-
-static ListSegment *CopyDataFromStructSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                              Allocator &allocator) {
-
-	auto source_child_count = functions.child_functions.size();
-	auto target = reinterpret_cast<ListSegment *>(AllocateStructData(allocator, source->capacity, source_child_count));
-	memcpy(target, source,
-	       sizeof(ListSegment) + source->capacity * sizeof(bool) + source_child_count * sizeof(ListSegment *));
-	target->next = nullptr;
-
-	// recurse and copy the children
-	auto source_child_segments = GetStructData(source);
-	auto target_child_segments = GetStructData(target);
-
-	for (idx_t i = 0; i < functions.child_functions.size(); i++) {
-		auto child_function = functions.child_functions[i];
-		auto source_child_segment = Load<ListSegment *>(const_data_ptr_cast(source_child_segments + i));
-		auto target_child_segment = child_function.copy_data(child_function, source_child_segment, allocator);
-		Store<ListSegment *>(target_child_segment, data_ptr_cast(target_child_segments + i));
-	}
-	return target;
-}
-
-void ListSegmentFunctions::CopyLinkedList(const LinkedList &source_list, LinkedList &target_list,
-                                          Allocator &allocator) const {
-	auto &copy_data_from_segment = *this;
-	auto source_segment = source_list.first_segment;
-
-	while (source_segment) {
-		auto target_segment = copy_data_from_segment.copy_data(copy_data_from_segment, source_segment, allocator);
-		source_segment = source_segment->next;
-
-		if (!target_list.first_segment) {
-			target_list.first_segment = target_segment;
-		}
-		if (target_list.last_segment) {
-			target_list.last_segment->next = target_segment;
-		}
-		target_list.last_segment = target_segment;
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Destroy
-//===--------------------------------------------------------------------===//
-void ListSegmentFunctions::Destroy(Allocator &allocator, LinkedList &linked_list) const {
-	DestroyLinkedList(*this, allocator, linked_list);
-}
 //===--------------------------------------------------------------------===//
 // Functions
 //===--------------------------------------------------------------------===//
@@ -592,8 +458,6 @@ void SegmentPrimitiveFunction(ListSegmentFunctions &functions) {
 	functions.create_segment = CreatePrimitiveSegment<T>;
 	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) {
@@ -644,8 +508,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateListSegment;
 		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());
@@ -655,8 +517,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateListSegment;
 		functions.write_data = WriteDataToListSegment;
 		functions.read_data = ReadDataFromListSegment;
-		functions.copy_data = CopyDataFromListSegment;
-		functions.destroy = DestroyListSegment;
 
 		// recurse
 		functions.child_functions.emplace_back();
@@ -667,8 +527,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateStructSegment;
 		functions.write_data = WriteDataToStructSegment;
 		functions.read_data = ReadDataFromStructSegment;
-		functions.copy_data = CopyDataFromStructSegment;
-		functions.destroy = DestroyStructSegment;
 
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);

package/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp

@@ -16,15 +16,6 @@ PartitionedTupleData::PartitionedTupleData(const PartitionedTupleData &other)
     : type(other.type), buffer_manager(other.buffer_manager), layout(other.layout.Copy()) {
 }
 
-unique_ptr<PartitionedTupleData> PartitionedTupleData::CreateShared() {
-	switch (type) {
-	case PartitionedTupleDataType::RADIX:
-		return make_uniq<RadixPartitionedTupleData>(Cast<RadixPartitionedTupleData>());
-	default:
-		throw NotImplementedException("CreateShared for this type of PartitionedTupleData");
-	}
-}
-
 PartitionedTupleData::~PartitionedTupleData() {
 }
 
@@ -233,6 +224,9 @@ void PartitionedTupleData::Combine(PartitionedTupleData &other) {
 }
 
 void PartitionedTupleData::Partition(TupleDataCollection &source, TupleDataPinProperties properties) {
+	if (source.Count() == 0) {
+		return;
+	}
 #ifdef DEBUG
 	const auto count_before = source.Count();
 #endif

package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/common/types/row/row_data_collection.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 
+#include <numeric>
+
 namespace duckdb {
 
 void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block_collection,
@@ -155,6 +157,31 @@ RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, Ro
 	ValidateUnscannedBlock();
 }
 
+RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
+                                                   const RowLayout &layout_p, bool external_p, idx_t block_idx,
+                                                   bool flush_p)
+    : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
+      external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
+
+	if (unswizzling) {
+		D_ASSERT(rows.blocks.size() == heap.blocks.size());
+	}
+
+	D_ASSERT(block_idx < rows.blocks.size());
+	read_state.block_idx = block_idx;
+	read_state.entry_idx = 0;
+
+	//	Pretend that we have scanned up to the start block
+	//	and will stop at the end
+	auto begin = rows.blocks.begin();
+	auto end = begin + block_idx;
+	total_scanned =
+	    std::accumulate(begin, end, idx_t(0), [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
+	total_count = total_scanned + (*end)->count;
+
+	ValidateUnscannedBlock();
+}
+
 void RowDataCollectionScanner::SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block) {
 	// Pin the data block and swizzle the pointers within the rows
 	D_ASSERT(!data_block.block->IsSwizzled());
@@ -190,7 +217,7 @@ void RowDataCollectionScanner::ReSwizzle() {
 }
 
 void RowDataCollectionScanner::ValidateUnscannedBlock() const {
-	if (unswizzling && read_state.block_idx < rows.blocks.size()) {
+	if (unswizzling && read_state.block_idx < rows.blocks.size() && Remaining()) {
 		D_ASSERT(rows.blocks[read_state.block_idx]->block->IsSwizzled());
 	}
 }
@@ -202,6 +229,9 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		return;
 	}
 
+	//	Only flush blocks we processed.
+	const auto flush_block_idx = read_state.block_idx;
+
 	const idx_t &row_width = layout.GetRowWidth();
 	// Set up a batch of pointers to scan data from
 	idx_t scanned = 0;
@@ -227,6 +257,8 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		}
 		// Update state indices
 		read_state.entry_idx += next;
+		scanned += next;
+		total_scanned += next;
 		if (read_state.entry_idx == data_block->count) {
 			// Pin completed blocks so we don't lose them
 			pinned_blocks.emplace_back(rows.buffer_manager.Pin(data_block->block));
@@ -238,7 +270,6 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 			read_state.entry_idx = 0;
 			ValidateUnscannedBlock();
 		}
-		scanned += next;
 	}
 	D_ASSERT(scanned == count);
 	// Deserialize the payload data
@@ -248,14 +279,13 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 	}
 	chunk.SetCardinality(count);
 	chunk.Verify();
-	total_scanned += scanned;
 
 	//	Switch to a new set of pinned blocks
 	read_state.pinned_blocks.swap(pinned_blocks);
 
 	if (flush) {
 		// Release blocks we have passed.
-		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
 			rows.blocks[i]->block = nullptr;
 			if (unswizzling) {
 				heap.blocks[i]->block = nullptr;
@@ -263,7 +293,7 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		}
 	} else if (unswizzling) {
 		// Reswizzle blocks we have passed so they can be flushed safely.
-		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
 			auto &data_block = rows.blocks[i];
 			if (data_block->block && !data_block->block->IsSwizzled()) {
 				SwizzleBlock(*data_block, *heap.blocks[i]);

package/src/duckdb/src/common/types/row/tuple_data_collection.cpp

@@ -220,6 +220,8 @@ void TupleDataCollection::AppendUnified(TupleDataPinState &pin_state, TupleDataC
 
 static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector &vector, const idx_t count) {
 	vector.ToUnifiedFormat(count, format.data);
+	format.original_sel = format.data.sel;
+	format.original_owned_sel.Initialize(format.data.owned_sel);
 	switch (vector.GetType().InternalType()) {
 	case PhysicalType::STRUCT: {
 		auto &entries = StructVector::GetEntries(vector);

package/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp

@@ -296,7 +296,7 @@ static void ApplySliceRecursive(const Vector &source_v, TupleDataVectorFormat &s
 	D_ASSERT(source_format.combined_list_data);
 	auto &combined_list_data = *source_format.combined_list_data;
 
-	combined_list_data.selection_data = source_format.data.sel->Slice(combined_sel, count);
+	combined_list_data.selection_data = source_format.original_sel->Slice(combined_sel, count);
 	source_format.data.owned_sel.Initialize(combined_list_data.selection_data);
 	source_format.data.sel = &source_format.data.owned_sel;
 
@@ -376,8 +376,8 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	for (idx_t i = 0; i < child_list_child_count; i++) {
 		combined_sel.set_index(i, 0);
 	}
-	idx_t combined_list_offset = 0;
 
+	idx_t combined_list_offset = 0;
 	for (idx_t i = 0; i < append_count; i++) {
 		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
 		if (!list_validity.RowIsValid(list_idx)) {

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

@@ -55,4 +55,8 @@ string_t StringHeap::EmptyString(idx_t len) {
 	return string_t(insert_pos, len);
 }
 
+idx_t StringHeap::SizeInBytes() const {
+	return allocator.SizeInBytes();
+}
+
 } // namespace duckdb