duckdb 0.8.2-dev2320.0 → 0.8.2-dev2399.0

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

@@ -96,7 +96,7 @@ static uint16_t GetCapacityForNewSegment(uint16_t capacity) {
 }
 
 //===--------------------------------------------------------------------===//
-// Create & Destroy
+// Create
 //===--------------------------------------------------------------------===//
 template <class T>
 static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
@@ -174,56 +174,55 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAlloc
 // Append
 //===--------------------------------------------------------------------===//
 template <class T>
-static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, ArenaAllocator &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, ArenaAllocator &allocator,
-                                      ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                      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;
@@ -236,37 +235,31 @@ static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, Are
 }
 
 static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                   ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                   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)));
@@ -276,35 +269,34 @@ static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaA
 }
 
 static void WriteDataToStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                     ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                     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(ArenaAllocator &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++;
@@ -458,86 +450,6 @@ void ListSegmentFunctions::BuildListVector(const LinkedList &linked_list, Vector
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Copy
-//===--------------------------------------------------------------------===//
-template <class T>
-static ListSegment *CopyDataFromPrimitiveSegment(const ListSegmentFunctions &, const ListSegment *source,
-                                                 ArenaAllocator &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,
-                                            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)));
-
-	// 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,
-                                              ArenaAllocator &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,
-                                          ArenaAllocator &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;
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // Functions
 //===--------------------------------------------------------------------===//
@@ -546,7 +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>;
 }
 
 void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type) {
@@ -597,7 +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.child_functions.emplace_back();
 		SegmentPrimitiveFunction<char>(functions.child_functions.back());
@@ -607,7 +517,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateListSegment;
 		functions.write_data = WriteDataToListSegment;
 		functions.read_data = ReadDataFromListSegment;
-		functions.copy_data = CopyDataFromListSegment;
 
 		// recurse
 		functions.child_functions.emplace_back();
@@ -618,7 +527,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateStructSegment;
 		functions.write_data = WriteDataToStructSegment;
 		functions.read_data = ReadDataFromStructSegment;
-		functions.copy_data = CopyDataFromStructSegment;
 
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);

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

@@ -892,6 +892,27 @@ void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &format) {
 	}
 }
 
+void Vector::RecursiveToUnifiedFormat(Vector &input, idx_t count, RecursiveUnifiedVectorFormat &data) {
+
+	input.ToUnifiedFormat(count, data.unified);
+
+	if (input.GetType().InternalType() == PhysicalType::LIST) {
+		auto &child = ListVector::GetEntry(input);
+		auto child_count = ListVector::GetListSize(input);
+		data.children.emplace_back();
+		Vector::RecursiveToUnifiedFormat(child, child_count, data.children.back());
+
+	} else if (input.GetType().InternalType() == PhysicalType::STRUCT) {
+		auto &children = StructVector::GetEntries(input);
+		for (idx_t i = 0; i < children.size(); i++) {
+			data.children.emplace_back();
+		}
+		for (idx_t i = 0; i < children.size(); i++) {
+			Vector::RecursiveToUnifiedFormat(*children[i], count, data.children[i]);
+		}
+	}
+}
+
 void Vector::Sequence(int64_t start, int64_t increment, idx_t count) {
 	this->vector_type = VectorType::SEQUENCE_VECTOR;
 	this->buffer = make_buffer<VectorBuffer>(sizeof(int64_t) * 3);

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

@@ -31,8 +31,6 @@ struct hash<duckdb::hugeint_t> {
 
 namespace duckdb {
 
-using FrameBounds = std::pair<idx_t, idx_t>;
-
 template <class KEY_TYPE>
 struct ModeState {
 	struct ModeAttr {
@@ -225,31 +223,31 @@ struct ModeFunction {
 		if (state.nonzero <= tau * state.frequency_map->size()) {
 			state.Reset();
 			// for f ∈ F do
-			for (auto f = frame.first; f < frame.second; ++f) {
+			for (auto f = frame.start; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 		} else {
 			// for f ∈ P \ F do
-			for (auto p = prev.first; p < frame.first; ++p) {
+			for (auto p = prev.start; p < frame.start; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
-			for (auto p = frame.second; p < prev.second; ++p) {
+			for (auto p = frame.end; p < prev.end; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
 
 			// for f ∈ F \ P do
-			for (auto f = frame.first; f < prev.first; ++f) {
+			for (auto f = frame.start; f < prev.start; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
-			for (auto f = prev.second; f < frame.second; ++f) {
+			for (auto f = prev.end; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}

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

@@ -37,8 +37,6 @@ inline interval_t operator-(const interval_t &lhs, const interval_t &rhs) {
 	return Interval::FromMicro(Interval::GetMicro(lhs) - Interval::GetMicro(rhs));
 }
 
-using FrameBounds = std::pair<idx_t, idx_t>;
-
 template <typename SAVE_TYPE>
 struct QuantileState {
 	using SaveType = SAVE_TYPE;
@@ -89,7 +87,7 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 	idx_t j = 0;
 
 	//  Copy overlapping indices
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
+	for (idx_t p = 0; p < (prev.end - prev.start); ++p) {
 		auto idx = index[p];
 
 		//  Shift down into any hole
@@ -98,7 +96,7 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 		}
 
 		//  Skip overlapping values
-		if (frame.first <= idx && idx < frame.second) {
+		if (frame.start <= idx && idx < frame.end) {
 			++j;
 		}
 	}
@@ -106,15 +104,15 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 	//  Insert new indices
 	if (j > 0) {
 		// Overlap: append the new ends
-		for (auto f = frame.first; f < prev.first; ++f, ++j) {
+		for (auto f = frame.start; f < prev.start; ++f, ++j) {
 			index[j] = f;
 		}
-		for (auto f = prev.second; f < frame.second; ++f, ++j) {
+		for (auto f = prev.end; f < frame.end; ++f, ++j) {
 			index[j] = f;
 		}
 	} else {
 		//  No overlap: overwrite with new values
-		for (auto f = frame.first; f < frame.second; ++f, ++j) {
+		for (auto f = frame.start; f < frame.end; ++f, ++j) {
 			index[j] = f;
 		}
 	}
@@ -124,17 +122,17 @@ static idx_t ReplaceIndex(idx_t *index, const FrameBounds &frame, const FrameBou
 	D_ASSERT(index);
 
 	idx_t j = 0;
-	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
+	for (idx_t p = 0; p < (prev.end - prev.start); ++p) {
 		auto idx = index[p];
 		if (j != p) {
 			break;
 		}
 
-		if (frame.first <= idx && idx < frame.second) {
+		if (frame.start <= idx && idx < frame.end) {
 			++j;
 		}
 	}
-	index[j] = frame.second - 1;
+	index[j] = frame.end - 1;
 
 	return j;
 }
@@ -560,7 +558,7 @@ struct QuantileScalarOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 		D_ASSERT(index);
@@ -572,11 +570,11 @@ struct QuantileScalarOperation : public QuantileOperation {
 		const auto q = bind_data.quantiles[0];
 
 		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				Interpolator<DISCRETE> interp(q, prev_pos, false);
 				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {
@@ -720,7 +718,7 @@ struct QuantileListOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 
@@ -731,11 +729,11 @@ struct QuantileListOperation : public QuantileOperation {
 		// then Q25 must be recomputed, but Q50 and Q75 are unaffected.
 		// For a single element list, this reduces to the scalar case.
 		std::pair<idx_t, idx_t> replaceable {state.pos, 0};
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				for (const auto &q : bind_data.order) {
 					const auto &quantile = bind_data.quantiles[q];
 					Interpolator<DISCRETE> interp(quantile, prev_pos, false);
@@ -1062,7 +1060,7 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 
 		//  Lazily initialise frame state
 		auto prev_pos = state.pos;
-		state.SetPos(frame.second - frame.first);
+		state.SetPos(frame.end - frame.start);
 
 		auto index = state.w.data();
 		D_ASSERT(index);
@@ -1085,11 +1083,11 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 		const float q = 0.5;
 
 		bool replace = false;
-		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
+		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
 			//  Fixed frame size
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
-			if (included.AllValid() || included(prev.first) == included(prev.second)) {
+			if (included.AllValid() || included(prev.start) == included(prev.end)) {
 				Interpolator<false> interp(q, prev_pos, false);
 				replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 				if (replace) {