Simplify error expr

Author: Subham Singhal

datafusion/spark/src/function/math/negative.rs

@@ -105,11 +105,9 @@ macro_rules! impl_integer_array_negative {
         let result: PrimitiveArray<$type> = if $enable_ansi_mode {
             array.try_unary(|x| {
                 x.checked_neg().ok_or_else(|| {
-                    arrow::error::ArrowError::from(
-                        (exec_err!("{} overflow on negative({x})", $type_name)
-                            as Result<(), _>)
-                            .unwrap_err(),
-                    )
+                    (exec_err!("{} overflow on negative({x})", $type_name)
+                        as Result<(), _>)
+                        .unwrap_err()
                 })
             })?
         } else {
@@ -136,11 +134,9 @@ macro_rules! impl_decimal_array_negative {
             array
                 .try_unary(|x| {
                     x.checked_neg().ok_or_else(|| {
-                        arrow::error::ArrowError::from(
-                            (exec_err!("{} overflow on negative({x})", $type_name)
-                                as Result<(), _>)
-                                .unwrap_err(),
-                        )
+                        (exec_err!("{} overflow on negative({x})", $type_name)
+                            as Result<(), _>)
+                            .unwrap_err()
                     })
                 })?
                 .with_data_type(array.data_type().clone())
@@ -257,20 +253,19 @@ fn spark_negative(
                 let result: PrimitiveArray<IntervalDayTimeType> = if enable_ansi_mode {
                     array.try_unary(|x| {
                         let days = x.days.checked_neg().ok_or_else(|| {
-                            arrow::error::ArrowError::from(
-                                (exec_err!(
-                                    "IntervalDayTime overflow on negative (days: {})",
-                                    x.days
-                                ) as Result<(), _>)
-                                    .unwrap_err(),
-                            )
+                            (exec_err!(
+                                "IntervalDayTime overflow on negative (days: {})",
+                                x.days
+                            ) as Result<(), _>)
+                                .unwrap_err()
                         })?;
                         let milliseconds =
                             x.milliseconds.checked_neg().ok_or_else(|| {
-                                arrow::error::ArrowError::from((exec_err!(
+                                (exec_err!(
                                 "IntervalDayTime overflow on negative (milliseconds: {})",
                                 x.milliseconds
-                            ) as Result<(), _>).unwrap_err())
+                            ) as Result<(), _>)
+                                .unwrap_err()
                             })?;
                         Ok::<_, arrow::error::ArrowError>(IntervalDayTime {
                             days,
@@ -291,19 +286,25 @@ fn spark_negative(
                 {
                     array.try_unary(|x| {
                         let months = x.months.checked_neg().ok_or_else(|| {
-                            arrow::error::ArrowError::from((exec_err!(
+                            (exec_err!(
                                 "IntervalMonthDayNano overflow on negative (months: {})",
                                 x.months
-                            ) as Result<(), _>).unwrap_err())
+                            ) as Result<(), _>)
+                                .unwrap_err()
                         })?;
                         let days = x.days.checked_neg().ok_or_else(|| {
-                            arrow::error::ArrowError::from((exec_err!("IntervalMonthDayNano overflow on negative (days: {})", x.days) as Result<(), _>).unwrap_err())
+                            (exec_err!(
+                                "IntervalMonthDayNano overflow on negative (days: {})",
+                                x.days
+                            ) as Result<(), _>)
+                                .unwrap_err()
                         })?;
                         let nanoseconds = x.nanoseconds.checked_neg().ok_or_else(|| {
-                            arrow::error::ArrowError::from((exec_err!(
+                            (exec_err!(
                                 "IntervalMonthDayNano overflow on negative (nanoseconds: {})",
                                 x.nanoseconds
-                            ) as Result<(), _>).unwrap_err())
+                            ) as Result<(), _>)
+                                .unwrap_err()
                         })?;
                         Ok::<_, arrow::error::ArrowError>(IntervalMonthDayNano {
                             months,

datafusion/sqllogictest/test_files/spark/math/negative.slt

@@ -320,7 +320,7 @@ SELECT negative((-9223372036854775807)::bigint);
 statement ok
 CREATE TABLE min_values_ansi AS VALUES (-2147483648);
 
-query error DataFusion error: Arrow error: External error: Execution error: Int32 overflow on negative\(\-2147483648\)
+query error DataFusion error: Execution error: Int32 overflow on negative\(\-2147483648\)
 SELECT negative(column1::int) FROM min_values_ansi;
 
 statement ok