Renames as per TODO

Author: theirix

datafusion/functions-aggregate/src/first_last.rs

@@ -220,7 +220,7 @@ impl AggregateUDFImpl for FirstValue {
                 .map(|e| e.expr.data_type(args.schema))
                 .collect::<Result<Vec<_>>>()?;
 
-            FirstPrimitiveGroupsAccumulator::<T>::try_new(
+            PrimitiveGroupsAccumulator::<T>::try_new(
                 ordering,
                 args.ignore_nulls,
                 args.return_field.data_type(),
@@ -311,8 +311,7 @@ impl AggregateUDFImpl for FirstValue {
     }
 }
 
-// TODO: rename to PrimitiveGroupsAccumulator
-struct FirstPrimitiveGroupsAccumulator<T>
+struct PrimitiveGroupsAccumulator<T>
 where
     T: ArrowPrimitiveType + Send,
 {
@@ -337,8 +336,7 @@ where
     // buffer for `get_filtered_min_of_each_group`
     // filter_min_of_each_group_buf.0[group_idx] -> idx_in_val
     // only valid if filter_min_of_each_group_buf.1[group_idx] == true
-    // TODO: rename to extreme_of_each_group_buf
-    min_of_each_group_buf: (Vec<usize>, BooleanBufferBuilder),
+    extreme_of_each_group_buf: (Vec<usize>, BooleanBufferBuilder),
 
     // =========== option ============
 
@@ -356,7 +354,7 @@ where
     default_orderings: Vec<ScalarValue>,
 }
 
-impl<T> FirstPrimitiveGroupsAccumulator<T>
+impl<T> PrimitiveGroupsAccumulator<T>
 where
     T: ArrowPrimitiveType + Send,
 {
@@ -385,7 +383,7 @@ where
             orderings: Vec::new(),
             is_sets: BooleanBufferBuilder::new(0),
             size_of_orderings: 0,
-            min_of_each_group_buf: (Vec::new(), BooleanBufferBuilder::new(0)),
+            extreme_of_each_group_buf: (Vec::new(), BooleanBufferBuilder::new(0)),
             pick_first_in_group,
         })
     }
@@ -468,8 +466,8 @@ where
 
         self.is_sets.resize(new_size);
 
-        self.min_of_each_group_buf.0.resize(new_size, 0);
-        self.min_of_each_group_buf.1.resize(new_size);
+        self.extreme_of_each_group_buf.0.resize(new_size, 0);
+        self.extreme_of_each_group_buf.1.resize(new_size);
     }
 
     fn update_state(
@@ -496,10 +494,10 @@ where
         &mut self,
         emit_to: EmitTo,
     ) -> (ArrayRef, Vec<Vec<ScalarValue>>, BooleanBuffer) {
-        emit_to.take_needed(&mut self.min_of_each_group_buf.0);
-        self.min_of_each_group_buf
+        emit_to.take_needed(&mut self.extreme_of_each_group_buf.0);
+        self.extreme_of_each_group_buf
             .1
-            .truncate(self.min_of_each_group_buf.0.len());
+            .truncate(self.extreme_of_each_group_buf.0.len());
 
         (
             self.take_vals_and_null_buf(emit_to),
@@ -519,8 +517,7 @@ where
     /// Returns a vector of tuples `(group_idx, idx_in_val)` representing the index of the
     /// minimum value in `orderings` for each group, using lexicographical comparison.
     /// Values are filtered using `opt_filter` and `is_set_arr` if provided.
-    /// TODO: rename to get_filtered_extreme_of_each_group
-    fn get_filtered_min_of_each_group(
+    fn get_filtered_extreme_of_each_group(
         &mut self,
         orderings: &[ArrayRef],
         group_indices: &[usize],
@@ -529,8 +526,8 @@ where
         is_set_arr: Option<&BooleanArray>,
     ) -> Result<Vec<(usize, usize)>> {
         // Set all values in min_of_each_group_buf.1 to false.
-        self.min_of_each_group_buf.1.truncate(0);
-        self.min_of_each_group_buf
+        self.extreme_of_each_group_buf.1.truncate(0);
+        self.extreme_of_each_group_buf
             .1
             .append_n(self.vals.len(), false);
 
@@ -565,29 +562,29 @@ where
                 continue;
             }
 
-            let is_valid = self.min_of_each_group_buf.1.get_bit(group_idx);
+            let is_valid = self.extreme_of_each_group_buf.1.get_bit(group_idx);
 
             if !is_valid {
-                self.min_of_each_group_buf.1.set_bit(group_idx, true);
-                self.min_of_each_group_buf.0[group_idx] = idx_in_val;
+                self.extreme_of_each_group_buf.1.set_bit(group_idx, true);
+                self.extreme_of_each_group_buf.0[group_idx] = idx_in_val;
             } else {
                 let ordering = comparator
-                    .compare(self.min_of_each_group_buf.0[group_idx], idx_in_val);
+                    .compare(self.extreme_of_each_group_buf.0[group_idx], idx_in_val);
 
                 if (ordering.is_gt() && self.pick_first_in_group)
                     || (ordering.is_lt() && !self.pick_first_in_group)
                 {
-                    self.min_of_each_group_buf.0[group_idx] = idx_in_val;
+                    self.extreme_of_each_group_buf.0[group_idx] = idx_in_val;
                 }
             }
         }
 
         Ok(self
-            .min_of_each_group_buf
+            .extreme_of_each_group_buf
             .0
             .iter()
             .enumerate()
-            .filter(|(group_idx, _)| self.min_of_each_group_buf.1.get_bit(*group_idx))
+            .filter(|(group_idx, _)| self.extreme_of_each_group_buf.1.get_bit(*group_idx))
             .map(|(group_idx, idx_in_val)| (group_idx, *idx_in_val))
             .collect::<Vec<_>>())
     }
@@ -603,7 +600,7 @@ where
     }
 }
 
-impl<T> GroupsAccumulator for FirstPrimitiveGroupsAccumulator<T>
+impl<T> GroupsAccumulator for PrimitiveGroupsAccumulator<T>
 where
     T: ArrowPrimitiveType + Send,
 {
@@ -623,7 +620,7 @@ where
 
         // The overhead of calling `extract_row_at_idx_to_buf` is somewhat high, so we need to minimize its calls as much as possible.
         for (group_idx, idx) in self
-            .get_filtered_min_of_each_group(
+            .get_filtered_extreme_of_each_group(
                 &values_and_order_cols[1..],
                 group_indices,
                 opt_filter,
@@ -704,7 +701,7 @@ where
 
         let vals = values[0].as_primitive::<T>();
         // The overhead of calling `extract_row_at_idx_to_buf` is somewhat high, so we need to minimize its calls as much as possible.
-        let groups = self.get_filtered_min_of_each_group(
+        let groups = self.get_filtered_extreme_of_each_group(
             &val_and_order_cols[1..],
             group_indices,
             opt_filter,
@@ -733,8 +730,8 @@ where
             + self.null_builder.capacity() / 8 // capacity is in bits, so convert to bytes
             + self.is_sets.capacity() / 8
             + self.size_of_orderings
-            + self.min_of_each_group_buf.0.capacity() * size_of::<usize>()
-            + self.min_of_each_group_buf.1.capacity() / 8
+            + self.extreme_of_each_group_buf.0.capacity() * size_of::<usize>()
+            + self.extreme_of_each_group_buf.1.capacity() / 8
     }
 
     fn supports_convert_to_state(&self) -> bool {
@@ -1185,7 +1182,7 @@ impl AggregateUDFImpl for LastValue {
                 .map(|e| e.expr.data_type(args.schema))
                 .collect::<Result<Vec<_>>>()?;
 
-            Ok(Box::new(FirstPrimitiveGroupsAccumulator::<T>::try_new(
+            Ok(Box::new(PrimitiveGroupsAccumulator::<T>::try_new(
                 ordering,
                 args.ignore_nulls,
                 args.return_field.data_type(),
@@ -1668,7 +1665,7 @@ mod tests {
             options: SortOptions::default(),
         }];
 
-        let mut group_acc = FirstPrimitiveGroupsAccumulator::<Int64Type>::try_new(
+        let mut group_acc = PrimitiveGroupsAccumulator::<Int64Type>::try_new(
             sort_keys.into(),
             true,
             &DataType::Int64,
@@ -1762,7 +1759,7 @@ mod tests {
             options: SortOptions::default(),
         }];
 
-        let mut group_acc = FirstPrimitiveGroupsAccumulator::<Int64Type>::try_new(
+        let mut group_acc = PrimitiveGroupsAccumulator::<Int64Type>::try_new(
             sort_keys.into(),
             true,
             &DataType::Int64,
@@ -1843,7 +1840,7 @@ mod tests {
             options: SortOptions::default(),
         }];
 
-        let mut group_acc = FirstPrimitiveGroupsAccumulator::<Int64Type>::try_new(
+        let mut group_acc = PrimitiveGroupsAccumulator::<Int64Type>::try_new(
             sort_keys.into(),
             true,
             &DataType::Int64,