re-run benchmarks

Author: Rich-T-kid

datafusion/physical-plan/src/aggregates/group_values/single_group_by/dictionary.rs

@@ -49,12 +49,11 @@ macro_rules! decode_list {
                         if len == -1 {
                             builder.values().append_null();
                         } else {
-                            let s = std::str::from_utf8(
-                                &raw_vector[offset..offset + len as usize],
-                            )
-                            .map_err(|e| {
-                                Internal(format!("Invalid utf8 in list element: {e}"))
-                            })?;
+                            let s = unsafe {
+                                std::str::from_utf8_unchecked(
+                                    &raw_vector[offset..offset + len as usize],
+                                )
+                            };
                             builder.values().append_value(s);
                             offset += len as usize;
                         }
@@ -72,9 +71,7 @@ macro_rules! decode_scalar_string {
         for raw_bytes in $raw {
             match raw_bytes {
                 Some(raw_vector) => {
-                    let s = std::str::from_utf8(raw_vector).map_err(|e| {
-                        Internal(format!("Invalid utf8 in GroupValuesDictionary: {e}"))
-                    })?;
+                    let s = unsafe { std::str::from_utf8_unchecked(raw_vector) };
                     builder.append_value(s);
                 }
                 None => builder.append_null(),
@@ -116,7 +113,6 @@ impl<K: ArrowDictionaryKeyType + Send> GroupValuesDictionary<K> {
         create_hashes([Arc::clone(values)], &self.random_state, &mut hashes)?;
         Ok(hashes)
     }
-
     fn get_raw_bytes(values: &ArrayRef, index: usize) -> Cow<'_, [u8]> {
         match values.data_type() {
             DataType::Utf8 => Cow::Borrowed(
@@ -256,33 +252,35 @@ impl<K: ArrowDictionaryKeyType + Send> GroupValuesDictionary<K> {
         key_array: &PrimitiveArray<K>,
     ) -> (ArrayRef, Vec<Option<usize>>) {
         let mut key_to_canonical: Vec<Option<usize>> = vec![None; values.len()];
+        let mut canonical_indices: Vec<usize> = Vec::with_capacity(key_array.len());
         let mut bytes_to_canonical: HashMap<Vec<u8>, usize> =
             HashMap::with_capacity(values.len());
-        let mut canonical_indices: Vec<usize> = Vec::with_capacity(key_array.len());
 
-        let new_keys: Vec<Option<usize>> = (0..key_array.len())
-            .map(|i| {
-                if key_array.is_null(i) {
-                    return None;
-                }
-                let old_key = key_array.value(i).to_usize().unwrap();
-                if let Some(canonical) = key_to_canonical[old_key] {
-                    return Some(canonical);
+        let mut new_keys: Vec<Option<usize>> = Vec::with_capacity(key_array.len());
+        for i in 0..key_array.len() {
+            if key_array.is_null(i) {
+                new_keys.push(None);
+                continue;
+            }
+            let old_key = key_array.value(i).to_usize().unwrap();
+            if let Some(canonical) = key_to_canonical[old_key] {
+                new_keys.push(Some(canonical));
+                continue;
+            }
+            let raw = Self::get_raw_bytes(values, old_key).to_vec();
+
+            let canonical = match bytes_to_canonical.get(&raw) {
+                Some(&idx) => idx,
+                None => {
+                    let idx = canonical_indices.len();
+                    canonical_indices.push(old_key);
+                    bytes_to_canonical.insert(raw, idx);
+                    idx
                 }
-                let raw = Self::get_raw_bytes(values, old_key).to_vec();
-                let canonical = match bytes_to_canonical.get(&raw) {
-                    Some(&idx) => idx,
-                    None => {
-                        let idx = canonical_indices.len();
-                        canonical_indices.push(old_key);
-                        bytes_to_canonical.insert(raw, idx);
-                        idx
-                    }
-                };
-                key_to_canonical[old_key] = Some(canonical);
-                Some(canonical)
-            })
-            .collect();
+            };
+            key_to_canonical[old_key] = Some(canonical);
+            new_keys.push(Some(canonical));
+        }
 
         let indices = UInt64Array::from(
             canonical_indices
@@ -298,7 +296,7 @@ impl<K: ArrowDictionaryKeyType + Send> GroupValuesDictionary<K> {
         values: &ArrayRef,
         key_array: &PrimitiveArray<K>,
     ) -> (ArrayRef, Vec<Option<usize>>) {
-        if values.len() < 20 {
+        if values.len() < 25 {
             //benchmarks show that for small arrays a nested loops works better due to cache locality and lower overhead,
             Self::normalize_dict_linear(values, key_array)
         } else {
@@ -334,7 +332,6 @@ impl<K: ArrowDictionaryKeyType + Send> GroupValues for GroupValuesDictionary<K>
             "GroupValuesDictionary only supports a single column"
         );
         let array = Arc::clone(&cols[0]);
-        groups.clear(); // zero out buffer
         let dict_array = array
             .as_any()
             .downcast_ref::<DictionaryArray<K>>()
@@ -353,6 +350,8 @@ impl<K: ArrowDictionaryKeyType + Send> GroupValues for GroupValuesDictionary<K>
         if key_array.is_empty() {
             return Ok(());
         }
+        groups.clear(); // zero out buffer
+        groups.reserve(key_array.len());
         let (values, keys_as_usize) = Self::normalize_dict_array(values, key_array);
 
         let values = &values;