duckdb 0.8.2-dev11.0 → 0.8.2-dev1212.0

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);

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/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/uuid.cpp

@@ -49,7 +49,7 @@ bool UUID::FromString(string str, hugeint_t &result) {
 		count++;
 	}
 	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
-	result.upper ^= (int64_t(1) << 63);
+	result.upper ^= (uint64_t(1) << 63);
 	return count == 32;
 }
 
@@ -61,7 +61,7 @@ void UUID::ToString(hugeint_t input, char *buf) {
 	};
 
 	// Flip back before convert to string
-	int64_t upper = input.upper ^ (int64_t(1) << 63);
+	int64_t upper = input.upper ^ (uint64_t(1) << 63);
 	idx_t pos = 0;
 	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
 	byte_to_hex(upper >> 48 & 0xFF, buf, pos);

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

@@ -96,6 +96,39 @@ void ValidityMask::SliceInPlace(const ValidityMask &other, idx_t target_offset,
 		memcpy(target_validity + target_offset_entries, source_validity + source_offset_entries,
 		       sizeof(validity_t) * EntryCount(count));
 		return;
+	} else if (IsAligned(target_offset)) {
+		//	Simple common case where we are shifting into an aligned mask (e.g., 0 in Slice above)
+		const idx_t entire_units = count / BITS_PER_VALUE;
+		const idx_t ragged = count % BITS_PER_VALUE;
+		const idx_t tail = source_offset % BITS_PER_VALUE;
+		const idx_t head = BITS_PER_VALUE - tail;
+		auto source_validity = other.GetData() + (source_offset / BITS_PER_VALUE);
+		auto target_validity = this->GetData() + (target_offset / BITS_PER_VALUE);
+		auto src_entry = *source_validity++;
+		for (idx_t i = 0; i < entire_units; ++i) {
+			//	Start with head of previous src
+			validity_t tgt_entry = src_entry >> tail;
+			src_entry = *source_validity++;
+			// 	Add in tail of current src
+			tgt_entry |= (src_entry << head);
+			*target_validity++ = tgt_entry;
+		}
+		//	Finish last ragged entry
+		if (ragged) {
+			//	Start with head of previous src
+			validity_t tgt_entry = (src_entry >> tail);
+			//  Add in the tail of the next src, if head was too small
+			if (head < ragged) {
+				src_entry = *source_validity++;
+				tgt_entry |= (src_entry << head);
+			}
+			//  Mask off the bits that go past the ragged end
+			tgt_entry &= (ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - ragged));
+			//	Restore the ragged end of the target
+			tgt_entry |= *target_validity & (ValidityBuffer::MAX_ENTRY << ragged);
+			*target_validity++ = tgt_entry;
+		}
+		return;
 	}
 
 	// FIXME: use bitwise operations here

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

@@ -855,38 +855,39 @@ void Vector::Flatten(const SelectionVector &sel, idx_t count) {
 	}
 }
 
-void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data) {
+void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &format) {
 	switch (GetVectorType()) {
 	case VectorType::DICTIONARY_VECTOR: {
 		auto &sel = DictionaryVector::SelVector(*this);
+		format.owned_sel.Initialize(sel);
+		format.sel = &format.owned_sel;
+
 		auto &child = DictionaryVector::Child(*this);
 		if (child.GetVectorType() == VectorType::FLAT_VECTOR) {
-			data.sel = &sel;
-			data.data = FlatVector::GetData(child);
-			data.validity = FlatVector::Validity(child);
+			format.data = FlatVector::GetData(child);
+			format.validity = FlatVector::Validity(child);
 		} else {
-			// dictionary with non-flat child: create a new reference to the child and normalify it
+			// dictionary with non-flat child: create a new reference to the child and flatten it
 			Vector child_vector(child);
 			child_vector.Flatten(sel, count);
 			auto new_aux = make_buffer<VectorChildBuffer>(std::move(child_vector));
 
-			data.sel = &sel;
-			data.data = FlatVector::GetData(new_aux->data);
-			data.validity = FlatVector::Validity(new_aux->data);
+			format.data = FlatVector::GetData(new_aux->data);
+			format.validity = FlatVector::Validity(new_aux->data);
 			this->auxiliary = std::move(new_aux);
 		}
 		break;
 	}
 	case VectorType::CONSTANT_VECTOR:
-		data.sel = ConstantVector::ZeroSelectionVector(count, data.owned_sel);
-		data.data = ConstantVector::GetData(*this);
-		data.validity = ConstantVector::Validity(*this);
+		format.sel = ConstantVector::ZeroSelectionVector(count, format.owned_sel);
+		format.data = ConstantVector::GetData(*this);
+		format.validity = ConstantVector::Validity(*this);
 		break;
 	default:
 		Flatten(count);
-		data.sel = FlatVector::IncrementalSelectionVector();
-		data.data = FlatVector::GetData(*this);
-		data.validity = FlatVector::Validity(*this);
+		format.sel = FlatVector::IncrementalSelectionVector();
+		format.data = FlatVector::GetData(*this);
+		format.validity = FlatVector::Validity(*this);
 		break;
 	}
 }

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -564,10 +564,12 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	SelectionVector lcursor(count);
 	SelectionVector rcursor(count);
 
-	ListVector::GetEntry(left).Flatten(ListVector::GetListSize(left));
-	ListVector::GetEntry(right).Flatten(ListVector::GetListSize(right));
-	Vector lchild(ListVector::GetEntry(left), lcursor, count);
-	Vector rchild(ListVector::GetEntry(right), rcursor, count);
+	Vector lentry_flattened(ListVector::GetEntry(left));
+	Vector rentry_flattened(ListVector::GetEntry(right));
+	lentry_flattened.Flatten(ListVector::GetListSize(left));
+	rentry_flattened.Flatten(ListVector::GetListSize(right));
+	Vector lchild(lentry_flattened, lcursor, count);
+	Vector rchild(rentry_flattened, rcursor, count);
 
 	// To perform the positional comparison, we use a vectorisation of the following algorithm:
 	// bool CompareLists(T *left, idx_t nleft, T *right, nright) {

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

@@ -21,8 +21,10 @@ struct ReservoirQuantileState {
 		if (new_len <= len) {
 			return;
 		}
+		T *old_v = v;
 		v = (T *)realloc(v, new_len * sizeof(T));
 		if (!v) {
+			free(old_v);
 			throw InternalException("Memory allocation failure");
 		}
 		len = new_len;

package/src/duckdb/src/core_functions/aggregate/nested/list.cpp

@@ -63,9 +63,9 @@ struct ListFunction {
 
 	template <class STATE>
 	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
-		auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
-		list_bind_data.functions.Destroy(aggr_input_data.allocator, state.linked_list);
+		// nop
 	}
+
 	static bool IgnoreNull() {
 		return false;
 	}

package/src/duckdb/src/core_functions/aggregate/regression/regr_avg.cpp

@@ -37,16 +37,16 @@ struct RegrAvgFunction {
 };
 struct RegrAvgXFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		state.sum += y;
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		state.sum += x;
 		state.count++;
 	}
 };
 
 struct RegrAvgYFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		state.sum += x;
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		state.sum += y;
 		state.count++;
 	}
 };

package/src/duckdb/src/core_functions/aggregate/regression/regr_intercept.cpp

@@ -23,11 +23,11 @@ struct RegrInterceptOperation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
 		state.count++;
-		state.sum_x += y;
-		state.sum_y += x;
-		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(state.slope, x, y, idata);
+		state.sum_x += x;
+		state.sum_y += y;
+		RegrSlopeOperation::Operation<A_TYPE, B_TYPE, RegrSlopeState, OP>(state.slope, y, x, idata);
 	}
 
 	template <class STATE, class OP>