test: add error asserts for zero scale decimal parsing

Author: gruuya

arrow-cast/src/parse.rs

@@ -836,8 +836,10 @@ fn parse_e_notation<T: DecimalType>(
 
 /// Parse the string format decimal value to i128/i256 format and checking the precision and scale.
 /// Expected behavior:
-/// - the result value can't be out of bounds.
-/// - when parsing a decimal with scale 0, any digits pass the decimal point will be discarded
+/// - The result value can't be out of bounds.
+/// - When parsing a decimal with scale 0, all fractional digits will be discarded. The final
+///   fractional digits may be a subset or a superset of the digits after the decimal point when
+///   e-notation is used.
 pub fn parse_decimal<T: DecimalType>(
     s: &str,
     precision: u8,
@@ -848,19 +850,19 @@ pub fn parse_decimal<T: DecimalType>(
     let mut digits: u8 = 0;
     let base = T::Native::usize_as(10);
 
+    if matches!(s, "" | "-" | "+" | "." | "1e" | "1e+" | "1e-") {
+        return Err(ArrowError::ParseError(format!(
+            "can't parse the string value {s} to decimal"
+        )));
+    }
+
     let bs = s.as_bytes();
     let (signed, negative) = match bs.first() {
         Some(b'-') => (true, true),
         Some(b'+') => (true, false),
         _ => (false, false),
     };
 
-    if bs.is_empty() || signed && bs.len() == 1 {
-        return Err(ArrowError::ParseError(format!(
-            "can't parse the string value {s} to decimal"
-        )));
-    }
-
     // Iterate over the raw input bytes, skipping the sign if any
     let mut bs = bs.iter().enumerate().skip(signed as usize);
 
@@ -918,13 +920,6 @@ pub fn parse_decimal<T: DecimalType>(
                 if is_e_notation {
                     break;
                 }
-
-                // Fail on "."
-                if digits == 0 && scale != 0 {
-                    return Err(ArrowError::ParseError(format!(
-                        "can't parse the string value {s} to decimal"
-                    )));
-                }
             }
             b'e' | b'E' => {
                 result = parse_e_notation::<T>(
@@ -2600,6 +2595,9 @@ mod tests {
             "1.1e.12",
             "1.23e+3.",
             "1.23e+3.1",
+            "1e",
+            "1e+",
+            "1e-",
         ];
         for s in can_not_parse_tests {
             let result_128 = parse_decimal::<Decimal128Type>(s, 20, 3);
@@ -2742,6 +2740,7 @@ mod tests {
         }
 
         let zero_scale_tests = [
+            (".123", 0, 3),
             ("0.123", 0, 3),
             ("1.0", 1, 3),
             ("1.2", 1, 3),
@@ -2769,6 +2768,15 @@ mod tests {
             let result_128 = parse_decimal::<Decimal128Type>(s, precision, 0).unwrap();
             assert_eq!(i, result_128);
         }
+
+        let can_not_parse_zero_scale = [".", "blag", "", "+", "-", "e"];
+        for s in can_not_parse_zero_scale {
+            let result_128 = parse_decimal::<Decimal128Type>(s, 5, 0);
+            assert_eq!(
+                format!("Parser error: can't parse the string value {s} to decimal"),
+                result_128.unwrap_err().to_string(),
+            );
+        }
     }
 
     #[test]