Skip all regular Accumulators if there are none

Author: srh

datafusion/src/physical_plan/hash_aggregate.rs

@@ -438,6 +438,9 @@ pub(crate) fn group_aggregate_batch(
     // Make sure we can create the accumulators or otherwise return an error
     create_accumulators(aggr_expr).map_err(DataFusionError::into_arrow_external_error)?;
 
+    let all_groups_accumulators: bool =
+        aggr_expr.iter().all(|expr| expr.uses_groups_accumulator());
+
     // Keys received in this batch
     let mut batch_keys = BinaryBuilder::new(0);
 
@@ -523,59 +526,57 @@ pub(crate) fn group_aggregate_batch(
         })
         .collect();
 
-    let mut group_indices = Vec::<usize>::new();
-
-    // 2.1 for each key in this batch
-    // 2.2 for each aggregation
-    // 2.3 `slice` from each of its arrays the keys' values
-    // 2.4 update / merge the accumulator with the values
-    // 2.5 clear indices
-    batch_keys
-        .iter()
-        .zip(offsets.windows(2))
-        .try_for_each(|(key, offsets)| {
-            let AccumulationGroupState {
-                accumulator_set,
-                indices,
-                group_index,
-                ..
-            } = accumulation_state
-                .accumulators
-                .get_mut(key.unwrap())
-                .unwrap();
-            // 2.2
-            accumulator_set
-                .iter_mut()
-                .zip(values.iter())
-                .map(|(accumulator, aggr_array)| {
-                    (
-                        accumulator,
-                        aggr_array
-                            .iter()
-                            .map(|array| {
-                                // 2.3
-                                array.slice(offsets[0], offsets[1] - offsets[0])
-                            })
-                            .collect::<Vec<ArrayRef>>(),
-                    )
-                })
-                .try_for_each(|(accumulator, values)| {
-                    if let Some(accumulator) = accumulator {
-                        match mode {
-                            AggregateMode::Partial | AggregateMode::Full => {
-                                accumulator.update_batch(&values)
-                            }
-                            AggregateMode::FinalPartitioned | AggregateMode::Final => {
-                                // note: the aggregation here is over states, not values, thus the merge
-                                accumulator.merge_batch(&values)
+    if !all_groups_accumulators {
+        // 2.1 for each key in this batch
+        // 2.2 for each aggregation
+        // 2.3 `slice` from each of its arrays the keys' values
+        // 2.4 update / merge the accumulator with the values
+        // 2.5 clear indices
+        batch_keys
+            .iter()
+            .zip(offsets.windows(2))
+            .try_for_each(|(key, offsets)| {
+                let AccumulationGroupState {
+                    accumulator_set, ..
+                } = accumulation_state
+                    .accumulators
+                    .get_mut(key.unwrap())
+                    .unwrap();
+                // 2.2
+                accumulator_set
+                    .iter_mut()
+                    .zip(values.iter())
+                    .map(|(accumulator, aggr_array)| {
+                        (
+                            accumulator,
+                            aggr_array
+                                .iter()
+                                .map(|array| {
+                                    // 2.3
+                                    array.slice(offsets[0], offsets[1] - offsets[0])
+                                })
+                                .collect::<Vec<ArrayRef>>(),
+                        )
+                    })
+                    .try_for_each(|(accumulator, values)| {
+                        if let Some(accumulator) = accumulator {
+                            match mode {
+                                AggregateMode::Partial | AggregateMode::Full => {
+                                    accumulator.update_batch(&values)
+                                }
+                                AggregateMode::FinalPartitioned
+                                | AggregateMode::Final => {
+                                    // note: the aggregation here is over states, not values, thus the merge
+                                    accumulator.merge_batch(&values)
+                                }
                             }
+                        } else {
+                            // We do groups accumulator separately.
+                            Ok(())
                         }
-                    } else {
-                        // We do groups accumulator separately.
-                        Ok(())
-                    }
-                })
-        })?;
+                    })
+            })?;
+    }
 
     for (accumulator_index, accumulator) in accumulation_state
         .groups_accumulators