@@ -389,19 +389,6 @@ fn sliced_array_benchmark(c: &mut Criterion) {
             );
         }
 
-        // Sliced DictionaryArray with one value per row of the full array, like
-        // the group keys an aggregation emits in `batch_size` slices
-        {
-            let full_array = distinct_dictionary_array(total_rows);
-            let sliced = full_array.slice(slice_offset, slice_len);
-            c.bench_function(
-                &format!("dictionary_sliced: 1/{ratio} of {total_rows} values"),
-                |b| {
-                    do_hash_test_with_len(b, std::slice::from_ref(&sliced), slice_len);
-                },
-            );
-        }
-
         // Sliced Dense UnionArray
         {
             let full_array = dense_union_array(total_rows);
@@ -420,6 +407,22 @@ fn sliced_array_benchmark(c: &mut Criterion) {
             );
         }
     }
+
+    // Sliced DictionaryArray with one value per row of the full array, like the
+    // group keys an aggregation emits in `batch_size` slices. Hashing reduces
+    // it to the referenced values only above 16 values per row, so 1/8 keeps
+    // the full dictionary and 1/32 doesn't.
+    for ratio in [8, 32] {
+        let total_rows = BATCH_SIZE * ratio;
+        let full_array = distinct_dictionary_array(total_rows);
+        let sliced = full_array.slice(BATCH_SIZE * (ratio / 2), BATCH_SIZE);
+        c.bench_function(
+            &format!("dictionary_sliced: 1/{ratio} of {total_rows} values"),
+            |b| {
+                do_hash_test_with_len(b, std::slice::from_ref(&sliced), BATCH_SIZE);
+            },
+        );
+    }
 }
 
 fn do_hash_test_with_len(b: &mut Bencher, arrays: &[ArrayRef], expected_len: usize) {
 
@@ -1869,19 +1869,19 @@ mod tests {
         use crate::utils::MAX_DICTIONARY_VALUES_PER_ROW;
 
         let values: ArrayRef = Arc::new(StringArray::from_iter(
-            (0..20).map(|i| (i != 2).then(|| format!("v{i}"))),
+            (0..40).map(|i| (i != 2).then(|| format!("v{i}"))),
         ));
-        let keys = Int8Array::from_iter((0..24).map(|i| (i % 7 != 1).then_some(i % 20)));
+        let keys = Int8Array::from_iter((0..48).map(|i| (i % 7 != 1).then_some(i % 40)));
         let dict: ArrayRef = Arc::new(DictionaryArray::try_new(keys, values).unwrap());
-        let ints: ArrayRef = Arc::new(Int32Array::from_iter_values(0..24));
+        let ints: ArrayRef = Arc::new(Int32Array::from_iter_values(0..48));
         let random_state = RandomState::with_seed(0);
 
         let mut single = vec![0; dict.len()];
         create_hashes([&dict], &random_state, &mut single).unwrap();
         let mut multi = vec![0; dict.len()];
         create_hashes([&ints, &dict], &random_state, &mut multi).unwrap();
 
-        for (offset, len) in [(0, 2), (1, 2), (8, 1), (22, 2)] {
+        for (offset, len) in [(0, 2), (1, 2), (8, 1), (46, 2)] {
             let slice = dict.slice(offset, len);
             assert!(
                 slice.as_any_dictionary().values().len()
 
@@ -441,9 +441,9 @@ where
 
 /// The most dictionary values per row that code processing every value of a
 /// dictionary should handle. Past this, taking the values the rows reference
-/// is cheaper than processing all of them, even for values that are cheap to
-/// process such as short strings or integers being hashed.
-pub const MAX_DICTIONARY_VALUES_PER_ROW: usize = 8;
+/// is cheaper than processing all of them, even for the cheapest per-value
+/// work, such as hashing integers or changing the case of ASCII strings.
+pub const MAX_DICTIONARY_VALUES_PER_ROW: usize = 16;
 
 /// Returns `None` when `array` has at most [`MAX_DICTIONARY_VALUES_PER_ROW`]
 /// values per row, and otherwise a copy whose values are `take(values, keys)`
@@ -2263,13 +2263,13 @@ mod tests {
 
     #[test]
     fn map_dictionary_values_bounds_values_per_row() -> Result<()> {
-        let strings = (0..12)
+        let strings = (0..24)
             .map(|i| (i % 5 != 1).then(|| "x".repeat(i)))
             .collect::<Vec<_>>();
         let dict: DictionaryArray<Int32Type> =
             strings.iter().map(|s| s.as_deref()).collect();
         let dict: ArrayRef = Arc::new(dict);
-        for (offset, len) in [(0, 12), (1, 1), (6, 1)] {
+        for (offset, len) in [(0, 24), (1, 1), (6, 1)] {
             let slice = dict.slice(offset, len);
             let mut seen = 0;
             let mapped = map_dictionary_values(&slice, |values| {
 
@@ -665,15 +665,15 @@ set datafusion.execution.target_partitions = 2;
 statement ok
 create table padded_groups as
 select arrow_cast(
-  case when value % 13 = 0 then null else ' Grp' || (value % 40) || ' ' end,
+  case when value % 13 = 0 then null else ' Grp' || (value % 100) || ' ' end,
   'Dictionary(Int32, Utf8)'
 ) as p
-from generate_series(1, 400);
+from generate_series(1, 1000);
 
 query I
 select count(*) from (select p from padded_groups group by p);
 ----
-41
+101
 
 # Each function on the grouped dictionary must match the same function on the
 # decoded value