@@ -1142,11 +1142,13 @@ config_namespace! {
         /// one after another and can be spilled and released independently;
         /// it does so at a quarter of this number when its input holds about
         /// one row per group. Aggregations of millions of groups per partition
-        /// run faster and with less memory. Moving rows into buckets has a
-        /// cost of its own, so aggregations that end at a few times this
-        /// number of groups, string keys in particular, can run a few percent
-        /// slower, and input that repeats its groups can use more memory.
-        /// Set to 0 to disable.
+        /// run faster and with less memory. Only aggregations whose group keys
+        /// and aggregate state are all fixed-width are affected: a string or
+        /// other variable-length value costs about as much to move into its
+        /// bucket as the smaller table saves. Moving rows has a cost of its
+        /// own, so aggregations that end at a few times this number of groups
+        /// can run a few percent slower, and input that repeats its groups can
+        /// use more memory. Set to 0 to disable.
         pub hash_aggregate_bucket_threshold: usize, default = 0
 
         /// Should DataFusion use row number estimates at the input to decide
 
@@ -22,7 +22,7 @@
 use std::sync::Arc;
 
 use arrow::compute::BatchCoalescer;
-use arrow::datatypes::SchemaRef;
+use arrow::datatypes::{DataType, SchemaRef};
 use arrow::record_batch::RecordBatch;
 use datafusion_common::{DataFusionError, Result};
 use datafusion_execution::memory_pool::MemoryReservation;
@@ -107,20 +107,16 @@ impl BucketedAggregation {
 
     /// True if a schema of partial state rows can be bucketed.
     ///
-    /// Bucketing turns the state of a table into rows and merges those rows
-    /// again. That is cheap for fixed-width and string state, but nested
-    /// state (the lists kept by `count(distinct)`, `array_agg` or `median`)
-    /// is costly to rebuild and takes more memory as rows than inside the
-    /// accumulator, so such aggregations keep their single table.
-    pub(super) fn supports_state(
-        state_schema: &SchemaRef,
-        num_group_columns: usize,
-    ) -> bool {
-        !state_schema
-            .fields()
-            .iter()
-            .skip(num_group_columns)
-            .any(|field| field.data_type().is_nested())
+    /// Bucketing moves every row once more before it is aggregated, which only
+    /// pays when moving a row is cheap compared to the cache miss it saves.
+    /// That holds for fixed-width columns. Variable-length keys or state
+    /// (strings, lists, ...) cost as much to move as the smaller tables save,
+    /// so such aggregations keep their single table.
+    pub(super) fn supports_state(state_schema: &SchemaRef) -> bool {
+        state_schema.fields().iter().all(|field| {
+            let data_type = field.data_type();
+            data_type.is_primitive() || *data_type == DataType::Boolean
+        })
     }
 
     pub(super) fn threshold(&self) -> usize {
@@ -365,3 +361,47 @@ impl BucketedAggregation {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use arrow::datatypes::{Field, Fields, Schema};
+
+    fn schema(types: Vec<DataType>) -> SchemaRef {
+        let fields: Fields = types
+            .into_iter()
+            .enumerate()
+            .map(|(i, data_type)| Field::new(format!("c{i}"), data_type, true))
+            .collect();
+        Arc::new(Schema::new(fields))
+    }
+
+    #[test]
+    fn only_fixed_width_state_is_bucketed() {
+        assert!(BucketedAggregation::supports_state(&schema(vec![
+            DataType::Int64,
+            DataType::Boolean,
+            DataType::Decimal128(38, 10),
+            DataType::Float64,
+            DataType::Date32,
+        ])));
+
+        // A variable-length group key or state column turns bucketing off
+        for variable_length in [
+            DataType::Utf8,
+            DataType::Utf8View,
+            DataType::LargeBinary,
+            DataType::List(Arc::new(Field::new_list_field(DataType::Int64, true))),
+        ] {
+            assert!(!BucketedAggregation::supports_state(&schema(vec![
+                DataType::Int64,
+                variable_length.clone(),
+            ])));
+            assert!(!BucketedAggregation::supports_state(&schema(vec![
+                variable_length,
+                DataType::Int64,
+            ])));
+        }
+    }
+}
@@ -384,14 +384,10 @@ impl PartialHashAggregateStream {
         let num_group_columns = agg.group_by().num_group_exprs();
         // Same conditions as for bucketing in the final aggregation, which
         // receives what is flushed here: see `FinalHashAggregateStream::new`.
-        let has_nested_state = schema
-            .fields()
-            .iter()
-            .skip(num_group_columns)
-            .any(|field| field.data_type().is_nested());
+        let fixed_width_state = BucketedAggregation::supports_state(&schema);
         let table_flush = (bucket_threshold > 0
             && group_values_soft_limit.is_none()
-            && !has_nested_state)
+            && fixed_width_state)
             .then(|| PartialTableFlush {
                 threshold: bucket_threshold,
                 num_group_columns,
@@ -833,10 +829,7 @@ impl FinalHashAggregateStream {
         // A soft limit stops reading input early, which bucketing cannot do.
         let bucketing = (bucket_threshold > 0
             && group_values_soft_limit.is_none()
-            && BucketedAggregation::supports_state(
-                &input_schema,
-                agg.group_by().num_group_exprs(),
-            ))
+            && BucketedAggregation::supports_state(&input_schema))
         .then(|| {
             Arc::new(BucketedAggregation::new(
                 bucket_threshold,
 
@@ -128,6 +128,9 @@ select count(*), round(sum(a), 3) from (select v % 10007 as k, avg(v) a from t g
 ----
 10007 1000705003.5
 
+# The next three queries have a string key, so they keep a single table: only
+# fixed-width state is bucketed. Their results must not change.
+
 # string key
 query II
 select count(*), sum(c) from (select concat('key-', cast(v % 9973 as varchar)) as k, count(*) c from t group by k);
 
@@ -385,7 +385,7 @@ datafusion.execution.enable_migration_aggregate true Whether aggregation uses th
 datafusion.execution.enable_nlj_coordinated_fallback true Enables the memory-limited fallback for `NestedLoopJoinExec` join types that emit unmatched left rows in the final output (LEFT, LEFT SEMI, LEFT ANTI, LEFT MARK, FULL) when the right side has multiple partitions. This fallback shares left-side state (the current left chunk, the visited bitmap and the probe-thread counter) across all right-side partitions, which assumes every partition runs in the same process. Distributed engines that execute each output partition as an independent task (e.g. Ballista, datafusion-distributed) give each task its own copy of this state and poll only one partition, so the cross-partition counter never reaches zero and the fallback would stall. Such engines should set this to `false`: the coordinated fallback is then disabled for left-emitting multi-partition joins, which instead fail with a resource-exhaustion error under memory pressure rather than deadlocking. Single-partition and non-left-emitting joins are unaffected and always keep the fallback.
 datafusion.execution.enable_recursive_ctes true Should DataFusion support recursive CTEs
 datafusion.execution.enforce_batch_size_in_joins false Should DataFusion enforce batch size in joins or not. By default, DataFusion will not enforce batch size in joins. Enforcing batch size in joins can reduce memory usage when joining large tables with a highly-selective join filter, but is also slightly slower. Note: this option currently only applies to the symmetric hash join.
-datafusion.execution.hash_aggregate_bucket_threshold 0 (experimental) Number of groups above which a hash aggregation stops growing a single hash table, so that its tables stay small enough to be cache friendly. A partial aggregation then emits the state of its table and starts over, as long as the emitted groups do not come back. A final aggregation splits the groups seen so far and all further input into hash buckets, which are aggregated one after another and can be spilled and released independently; it does so at a quarter of this number when its input holds about one row per group. Aggregations of millions of groups per partition run faster and with less memory. Moving rows into buckets has a cost of its own, so aggregations that end at a few times this number of groups, string keys in particular, can run a few percent slower, and input that repeats its groups can use more memory. Set to 0 to disable.
+datafusion.execution.hash_aggregate_bucket_threshold 0 (experimental) Number of groups above which a hash aggregation stops growing a single hash table, so that its tables stay small enough to be cache friendly. A partial aggregation then emits the state of its table and starts over, as long as the emitted groups do not come back. A final aggregation splits the groups seen so far and all further input into hash buckets, which are aggregated one after another and can be spilled and released independently; it does so at a quarter of this number when its input holds about one row per group. Aggregations of millions of groups per partition run faster and with less memory. Only aggregations whose group keys and aggregate state are all fixed-width are affected: a string or other variable-length value costs about as much to move into its bucket as the smaller table saves. Moving rows has a cost of its own, so aggregations that end at a few times this number of groups can run a few percent slower, and input that repeats its groups can use more memory. Set to 0 to disable.
 datafusion.execution.hash_join_buffering_capacity 0 How many bytes to buffer in the probe side of hash joins while the build side is concurrently being built. Without this, hash joins will wait until the full materialization of the build side before polling the probe side. This is useful in scenarios where the query is not completely CPU bounded, allowing to do some early work concurrently and reducing the latency of the query. Note that when hash join buffering is enabled, the probe side will start eagerly polling data, not giving time for the producer side of dynamic filters to produce any meaningful predicate. Queries with dynamic filters might see performance degradation. Disabled by default, set to a number greater than 0 for enabling it.
 datafusion.execution.keep_partition_by_columns false Should DataFusion keep the columns used for partition_by in the output RecordBatches
 datafusion.execution.listing_table_factory_infer_partitions true Should a `ListingTable` created through the `ListingTableFactory` infer table partitions from Hive compliant directories. Defaults to true (partition columns are inferred and will be represented in the table schema).