Complete

apache · Aug 2, 2022 · 5f14220 · 5f14220
1 parent a33508b
commit 5f14220
Showing 1 changed file with 37 additions and 67 deletions.
diff --git a/arrow/src/compute/kernels/cast.rs b/arrow/src/compute/kernels/cast.rs
@@ -1723,19 +1723,15 @@ fn cast_string_to_time64microsecond<Offset: OffsetSizeTrait>(
         .unwrap();
 
     let array = if cast_options.safe {
-        let iter = (0..string_array.len()).map(|i| {
-            if string_array.is_null(i) {
-                None
-            } else {
-                string_array
-                    .value(i)
-                    .parse::<chrono::NaiveTime>()
+        let iter = string_array.iter().map(|v| {
+            v.and_then(|v| {
+                v.parse::<chrono::NaiveTime>()
                     .map(|time| {
                         time.num_seconds_from_midnight() as i64 * MICROS_PER_SEC
                             + time.nanosecond() as i64 / NANOS_PER_MICRO
                     })
                     .ok()
-            }
+            })
         });
 
         // Benefit:
@@ -1744,26 +1740,20 @@ fn cast_string_to_time64microsecond<Offset: OffsetSizeTrait>(
         //     The iterator is trustedLen because it comes from an `StringArray`.
         unsafe { Time64MicrosecondArray::from_trusted_len_iter(iter) }
     } else {
-        let vec = (0..string_array.len())
-            .map(|i| {
-                if string_array.is_null(i) {
-                    Ok(None)
-                } else {
-                    let string = string_array
-                        .value(i);
-
-                    let result = string
+        let vec = string_array.iter()
+            .map(|v| {
+                v.map(|v| {
+                    v
                         .parse::<chrono::NaiveTime>()
                         .map(|time| time.num_seconds_from_midnight() as i64 * MICROS_PER_SEC
-                            + time.nanosecond() as i64 / NANOS_PER_MICRO);
-
-                    Some(result.map_err(|_| {
-                        ArrowError::CastError(
-                            format!("Cannot cast string '{}' to value of arrow::datatypes::types::Time64MicrosecondType type", string),
-                        )
-                    }))
-                        .transpose()
-                }
+                             + time.nanosecond() as i64 / NANOS_PER_MICRO)
+                        .map_err(|_| {
+                            ArrowError::CastError(
+                                format!("Cannot cast string '{}' to value of arrow::datatypes::types::Time64MicrosecondType type", v),
+                            )
+                        })
+                })
+                    .transpose()
             })
             .collect::<Result<Vec<Option<i64>>>>()?;
 
@@ -1791,19 +1781,15 @@ fn cast_string_to_time64nanosecond<Offset: OffsetSizeTrait>(
         .unwrap();
 
     let array = if cast_options.safe {
-        let iter = (0..string_array.len()).map(|i| {
-            if string_array.is_null(i) {
-                None
-            } else {
-                string_array
-                    .value(i)
-                    .parse::<chrono::NaiveTime>()
+        let iter = string_array.iter().map(|v| {
+            v.and_then(|v| {
+                v.parse::<chrono::NaiveTime>()
                     .map(|time| {
                         time.num_seconds_from_midnight() as i64 * NANOS_PER_SEC
                             + time.nanosecond() as i64
                     })
                     .ok()
-            }
+            })
         });
 
         // Benefit:
@@ -1812,25 +1798,19 @@ fn cast_string_to_time64nanosecond<Offset: OffsetSizeTrait>(
         //     The iterator is trustedLen because it comes from an `StringArray`.
         unsafe { Time64NanosecondArray::from_trusted_len_iter(iter) }
     } else {
-        let vec = (0..string_array.len())
-            .map(|i| {
-                if string_array.is_null(i) {
-                    Ok(None)
-                } else {
-                    let string = string_array
-                        .value(i);
-
-                    let result = string
+        let vec = string_array.iter()
+            .map(|v| {
+                v.map(|v| {
+                    v
                         .parse::<chrono::NaiveTime>()
-                        .map(|time| time.num_seconds_from_midnight() as i64 * NANOS_PER_SEC + time.nanosecond() as i64);
-
-                    Some(result.map_err(|_| {
-                        ArrowError::CastError(
-                            format!("Cannot cast string '{}' to value of arrow::datatypes::types::Time64NanosecondType type", string),
+                        .map(|time| time.num_seconds_from_midnight() as i64 * NANOS_PER_SEC + time.nanosecond() as i64)
+                        .map_err(|_| {
+                            ArrowError::CastError(
+                                format!("Cannot cast string '{}' to value of arrow::datatypes::types::Time64NanosecondType type", v),
                         )
-                    }))
-                        .transpose()
-                }
+                        })
+                })
+                    .transpose()
             })
             .collect::<Result<Vec<Option<i64>>>>()?;
 
@@ -1855,28 +1835,18 @@ fn cast_string_to_timestamp_ns<Offset: OffsetSizeTrait>(
         .unwrap();
 
     let array = if cast_options.safe {
-        let iter = (0..string_array.len()).map(|i| {
-            if string_array.is_null(i) {
-                None
-            } else {
-                string_to_timestamp_nanos(string_array.value(i)).ok()
-            }
-        });
+        let iter = string_array
+            .iter()
+            .map(|v| v.and_then(|v| string_to_timestamp_nanos(v).ok()));
         // Benefit:
         //     20% performance improvement
         // Soundness:
         //     The iterator is trustedLen because it comes from an `StringArray`.
         unsafe { TimestampNanosecondArray::from_trusted_len_iter(iter) }
     } else {
-        let vec = (0..string_array.len())
-            .map(|i| {
-                if string_array.is_null(i) {
-                    Ok(None)
-                } else {
-                    let result = string_to_timestamp_nanos(string_array.value(i));
-                    Some(result).transpose()
-                }
-            })
+        let vec = string_array
+            .iter()
+            .map(|v| v.map(string_to_timestamp_nanos).transpose())
             .collect::<Result<Vec<Option<i64>>>>()?;
 
         // Benefit: