For CastOptions.safe as false case, applying optimized casting

arrow-cast/src/cast.rs

@@ -3429,27 +3429,39 @@ where
         .as_any()
         .downcast_ref::<GenericByteArray<GenericBinaryType<I>>>()
         .unwrap();
-    Ok(Arc::new(
-        array
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(value) => {
-                    let result = std::str::from_utf8(value);
-                    if cast_options.safe {
-                        Ok(result.ok())
-                    } else {
-                        Some(result.map_err(|_| {
-                            ArrowError::CastError(
-                                "Cannot cast binary to string".to_string(),
-                            )
-                        }))
-                        .transpose()
-                    }
-                }
-                None => Ok(None),
-            })
-            .collect::<Result<GenericByteArray<GenericStringType<O>>, _>>()?,
-    ))
+
+    if !cast_options.safe {
+        let offsets = array.value_offsets();
+        let values = array.value_data();
+
+        // We only need to validate that all values are valid UTF-8
+        let validated = std::str::from_utf8(values)
+            .map_err(|_| ArrowError::CastError("Invalid UTF-8 sequence".to_string()))?;
+        for offset in offsets.iter() {
+            if !validated.is_char_boundary(offset.as_usize()) {
+                return Err(ArrowError::CastError("Invalid UTF-8 sequence".to_string()));
+            }
+        }
+
+        let builder = array
+            .into_data()
+            .into_builder()
+            .data_type(GenericStringArray::<O>::DATA_TYPE);
+        // SAFETY:
+        // Validated UTF-8 above
+        Ok(Arc::new(GenericStringArray::<O>::from(unsafe {
+            builder.build_unchecked()
+        })))
+    } else {
+        Ok(Arc::new(
+            array
+                .iter()
+                .map(|maybe_value| {
+                    maybe_value.and_then(|value| std::str::from_utf8(value).ok())
+                })
+                .collect::<GenericByteArray<GenericStringType<O>>>(),
+        ))
+    }
 }
 
 /// Helper function to cast from one `ByteArrayType` to another and vice versa.