duckdb 0.8.2-dev161.0 → 0.8.2-dev1764.0

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

@@ -678,7 +678,7 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 	result.is_null = false;
 	// add the tag to the front of the struct
 	vector<Value> union_values;
-	union_values.emplace_back(Value::TINYINT(tag));
+	union_values.emplace_back(Value::UTINYINT(tag));
 	for (idx_t i = 0; i < members.size(); i++) {
 		if (i != tag) {
 			union_values.emplace_back(members[i].second);
@@ -1465,20 +1465,25 @@ const vector<Value> &ListValue::GetChildren(const Value &value) {
 }
 
 const Value &UnionValue::GetValue(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto &children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
 	D_ASSERT(tag < children.size() - 1);
 	return children[tag + 1];
 }
 
-uint8_t UnionValue::GetTag(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+union_tag_t UnionValue::GetTag(const Value &value) {
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
+	D_ASSERT(tag < children.size() - 1);
 	return tag;
 }
 
+const LogicalType &UnionValue::GetType(const Value &value) {
+	return UnionType::GetMemberType(value.type(), UnionValue::GetTag(value));
+}
+
 hugeint_t IntegralValue::Get(const Value &value) {
 	switch (value.type().InternalType()) {
 	case PhysicalType::INT8: