fix_issue

Author: B Vadlamani

native/spark-expr/benches/cast_from_string.rs

@@ -68,6 +68,27 @@ fn criterion_benchmark(c: &mut Criterion) {
         b.iter(|| cast_to_i64.evaluate(&decimal_batch).unwrap());
     });
     group.finish();
+
+     // str -> decimal benchmark
+    let decimal_string_batch = create_decimal_cast_string_batch();
+    for (mode, mode_name) in [
+        (EvalMode::Legacy, "legacy"),
+        (EvalMode::Ansi, "ansi"),
+        (EvalMode::Try, "try"),
+    ] {
+        let spark_cast_options = SparkCastOptions::new(mode, "", false);
+        let cast_to_decimal_38_10 = Cast::new(
+            expr.clone(),
+            DataType::Decimal128(38, 10),
+            spark_cast_options,
+        );
+
+        let mut group = c.benchmark_group(format!("cast_string_to_decimal/{}", mode_name));
+        group.bench_function("decimal_38_10", |b| {
+            b.iter(|| cast_to_decimal_38_10.evaluate(&decimal_string_batch).unwrap());
+        });
+        group.finish();
+    }
 }
 
 /// Create batch with small integer strings that fit in i8 range (for i8/i16 benchmarks)
@@ -118,6 +139,51 @@ fn create_decimal_string_batch() -> RecordBatch {
     RecordBatch::try_new(schema, vec![Arc::new(array)]).unwrap()
 }
 
+/// Create batch with decimal strings for string-to-decimal cast perf evaluation
+fn create_decimal_cast_string_batch() -> RecordBatch {
+    let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
+    let mut b = StringBuilder::new();
+    for i in 0..1000 {
+        if i % 10 == 0 {
+            b.append_null();
+        } else {
+            // Generate various decimal formats
+            match i % 5 {
+                0 => {
+                    // gen simple decimals (ex :  "123.45"
+                    let int_part: u32 = rand::random::<u32>() % 1000000;
+                    let dec_part: u32 = rand::random::<u32>() % 100000;
+                    b.append_value(format!("{}.{}", int_part, dec_part));
+                }
+                1 => {
+                    // gen scientific notation like "123e5"
+                    let mantissa: u32 = rand::random::<u32>() % 1000;
+                    let exp: i8 = (rand::random::<i8>() % 10).abs();
+                    b.append_value(format!("{}.{}E{}", mantissa / 100, mantissa % 100, exp));
+                }
+                2 => {
+                    // Negative numbers
+                    let int_part: u32 = rand::random::<u32>() % 1000000;
+                    let dec_part: u32 = rand::random::<u32>() % 100000;
+                    b.append_value(format!("-{}.{}", int_part, dec_part));
+                }
+                3 => {
+                    // Ints only
+                    let val: i32 = rand::random::<i32>() % 1000000;
+                    b.append_value(format!("{}", val));
+                }
+                _ => {
+                    // Small decimals (ex : 0.001)
+                    let dec_part: u32 = rand::random::<u32>() % 100000;
+                    b.append_value(format!("0.{:05}", dec_part));
+                }
+            }
+        }
+    }
+    let array = b.finish();
+    RecordBatch::try_new(schema, vec![Arc::new(array)]).unwrap()
+}
+
 fn config() -> Criterion {
     Criterion::default()
 }

native/spark-expr/src/conversion_funcs/cast.rs

@@ -2348,12 +2348,7 @@ fn parse_string_to_decimal(input_str: &str, precision: u8, scale: i8) -> SparkRe
     }
 
     // validate and parse mantissa and exponent or bubble up the error
-    let (mantissa, exponent) = parse_decimal_str(
-        trimmed,
-        input_str,
-        "STRING",
-        &format!("DECIMAL({},{})", precision, scale),
-    )?;
+    let (mantissa, exponent) = parse_decimal_str(trimmed, input_str, precision, scale)?;
 
     // Early return mantissa 0, Spark checks if it fits digits and throw error in ansi
     if mantissa == 0 {
@@ -2429,16 +2424,20 @@ fn parse_string_to_decimal(input_str: &str, precision: u8, scale: i8) -> SparkRe
     }
 }
 
+fn invalid_decimal_cast(value: &str, precision: u8, scale: i8) -> SparkError {
+    invalid_value(value,"STRING", &format!("DECIMAL({},{})", precision, scale))
+}
+
 /// Parse a decimal string into mantissa and scale
 /// e.g., "123.45" -> (12345, 2), "-0.001" -> (-1, 3) , 0e50 -> (0,50) etc
 fn parse_decimal_str(
     s: &str,
     original_str: &str,
-    from_type: &str,
-    to_type: &str,
+    precision: u8,
+    scale: i8,
 ) -> SparkResult<(i128, i32)> {
     if s.is_empty() {
-        return Err(invalid_value(original_str, from_type, to_type));
+        return Err(invalid_decimal_cast(original_str, precision, scale));
     }
 
     let (mantissa_str, exponent) = if let Some(e_pos) = s.find(|c| ['e', 'E'].contains(&c)) {
@@ -2447,7 +2446,7 @@ fn parse_decimal_str(
         // Parse exponent
         let exp: i32 = exponent_part
             .parse()
-            .map_err(|_| invalid_value(original_str, from_type, to_type))?;
+            .map_err(|_| invalid_decimal_cast(original_str, precision, scale))?;
 
         (mantissa_part, exp)
     } else {
@@ -2462,29 +2461,29 @@ fn parse_decimal_str(
     };
 
     if mantissa_str.starts_with('+') || mantissa_str.starts_with('-') {
-        return Err(invalid_value(original_str, from_type, to_type));
+        return Err(invalid_decimal_cast(original_str, precision, scale));
     }
 
     let (integral_part, fractional_part) = match mantissa_str.find('.') {
         Some(dot_pos) => {
             if mantissa_str[dot_pos + 1..].contains('.') {
-                return Err(invalid_value(original_str, from_type, to_type));
+                return Err(invalid_decimal_cast(original_str, precision, scale));
             }
             (&mantissa_str[..dot_pos], &mantissa_str[dot_pos + 1..])
         }
         None => (mantissa_str, ""),
     };
 
     if integral_part.is_empty() && fractional_part.is_empty() {
-        return Err(invalid_value(original_str, from_type, to_type));
+        return Err(invalid_decimal_cast(original_str, precision, scale));
     }
 
     if !integral_part.is_empty() && !integral_part.bytes().all(|b| b.is_ascii_digit()) {
-        return Err(invalid_value(original_str, from_type, to_type));
+        return Err(invalid_decimal_cast(original_str, precision, scale));
     }
 
     if !fractional_part.is_empty() && !fractional_part.bytes().all(|b| b.is_ascii_digit()) {
-        return Err(invalid_value(original_str, from_type, to_type));
+        return Err(invalid_decimal_cast(original_str, precision, scale));
     }
 
     // Parse integral part
@@ -2494,7 +2493,7 @@ fn parse_decimal_str(
     } else {
         integral_part
             .parse()
-            .map_err(|_| invalid_value(original_str, from_type, to_type))?
+            .map_err(|_| invalid_decimal_cast(original_str, precision, scale))?
     };
 
     // Parse fractional part
@@ -2504,14 +2503,14 @@ fn parse_decimal_str(
     } else {
         fractional_part
             .parse()
-            .map_err(|_| invalid_value(original_str, from_type, to_type))?
+            .map_err(|_| invalid_decimal_cast(original_str, precision, scale))?
     };
 
     // Combine: value = integral * 10^fractional_scale + fractional
     let mantissa = integral_value
         .checked_mul(10_i128.pow(fractional_scale as u32))
         .and_then(|v| v.checked_add(fractional_value))
-        .ok_or_else(|| invalid_value(original_str, from_type, to_type))?;
+        .ok_or_else(|| invalid_decimal_cast(original_str, precision, scale))?;
 
     let final_mantissa = if negative { -mantissa } else { mantissa };
     // final scale = fractional_scale - exponent