rename function and update comment

Author: rluvaton

datafusion/expr-common/src/groups_accumulator.rs

@@ -111,13 +111,13 @@ pub trait GroupsAccumulator: Send {
     ///
     /// this is when the accumulator would benefit from knowing the order of the group indices.
     ///
-    fn group_order_sensitivity(&self) -> bool {
+    fn supports_with_group_indices_order_mode(&self) -> bool {
         false
     }
 
     /// Called with the order mode for the group indices.
     ///
-    /// This will only be called if [`Self::group_order_sensitivity`] is true and can be called either right after initialization
+    /// This will only be called if [`Self::supports_with_group_indices_order_mode`] is true and can be called either right after initialization
     /// or after [`Self::state`], [`Self::evaluate`] consumed all the groups.
     ///
     /// For example if `group_indices_order_mode` equals to [`InputOrderMode::Sorted`] it means that if you get the following group indices in [`Self::update_batch`]/[`Self::merge_batch`]
@@ -136,7 +136,7 @@ pub trait GroupsAccumulator: Send {
         self: Box<Self>,
         _group_indices_order_mode: &InputOrderMode,
     ) -> Result<Box<dyn GroupsAccumulator>> {
-        if self.group_order_sensitivity() {
+        if self.supports_with_group_indices_order_mode() {
             not_impl_err!("with_group_indices_order_mode not implemented")
         } else {
             exec_err!(

datafusion/functions-aggregate-common/src/aggregate/groups_accumulator.rs

@@ -220,7 +220,7 @@ impl GroupsAccumulatorAdapter {
     /// invokes f(accumulator, values) for each group that has values
     /// in group_indices.
     ///
-    /// if the group indices are contiguous we avoiding
+    /// Returns (usize, usize) which is (accumulators memory before invocation, accumulators memory after invocation)
     ///
     /// This function first reorders the input and filter so that
     /// values for each group_index are contiguous and then invokes f
@@ -322,6 +322,8 @@ impl GroupsAccumulatorAdapter {
     /// This function is the same as [`Self::invoke_per_accumulator_on_non_ordered_group_indices`] but avoid reordering of the
     /// input as we know that each group_index is contiguous
     ///
+    /// Returns (usize, usize) which is (accumulators memory before invocation, accumulators memory after invocation)
+    ///
     fn invoke_per_accumulator_on_contiguous_group_indices<F>(
         &mut self,
         values: &[ArrayRef],
@@ -421,7 +423,7 @@ impl GroupsAccumulatorAdapter {
 }
 
 impl GroupsAccumulator for GroupsAccumulatorAdapter {
-    fn group_order_sensitivity(&self) -> bool {
+    fn supports_with_group_indices_order_mode(&self) -> bool {
         true
     }
 

datafusion/physical-plan/src/aggregates/row_hash.rs

@@ -640,7 +640,7 @@ pub(crate) fn create_group_accumulator(
             Box::new(GroupsAccumulatorAdapter::new(factory))
         };
 
-    group_accumulator = if group_accumulator.group_order_sensitivity() {
+    group_accumulator = if group_accumulator.supports_with_group_indices_order_mode() {
         group_accumulator.with_group_indices_order_mode(input_order_mode)?
     } else {
         group_accumulator
@@ -1106,7 +1106,7 @@ impl GroupedHashAggregateStream {
                 .accumulators
                 .drain(..)
                 .map(|acc| {
-                    if acc.group_order_sensitivity() {
+                    if acc.supports_with_group_indices_order_mode() {
                         acc.with_group_indices_order_mode(&InputOrderMode::Sorted)
                     } else {
                         Ok(acc)