You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by al...@apache.org on 2022/09/17 10:46:23 UTC

[arrow-datafusion] branch master updated: fix divide by zero not throwing proper error for decimal (#3517)

This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git


The following commit(s) were added to refs/heads/master by this push:
     new b106b02a3 fix divide by zero not throwing proper error for decimal (#3517)
b106b02a3 is described below

commit b106b02a362a011bd8666cd2ae146fb6cfa7c4e4
Author: Kirk Mitchener <km...@gmail.com>
AuthorDate: Sat Sep 17 06:46:16 2022 -0400

    fix divide by zero not throwing proper error for decimal (#3517)
    
    * fix divide by zero for decimal, add tests
    
    * check for actual error strings
    
    * move scalar divide by zero check out of the loop. fix precision in test.
---
 .../src/expressions/binary/kernels_arrow.rs        | 52 +++++++++++++++++++---
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs b/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
index e99fbf0c9..8caed7191 100644
--- a/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
+++ b/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs
@@ -378,6 +378,9 @@ pub(crate) fn divide_decimal(
 ) -> Result<Decimal128Array> {
     let mul = 10_f64.powi(left.scale() as i32);
     let array = arith_decimal(left, right, |left, right| {
+        if right == 0 {
+            return Err(DataFusionError::ArrowError(ArrowError::DivideByZero));
+        }
         let l_value = left as f64;
         let r_value = right as f64;
         let result = ((l_value / r_value) * mul) as i128;
@@ -391,6 +394,9 @@ pub(crate) fn divide_decimal_scalar(
     left: &Decimal128Array,
     right: i128,
 ) -> Result<Decimal128Array> {
+    if right == 0 {
+        return Err(DataFusionError::ArrowError(ArrowError::DivideByZero));
+    }
     let mul = 10_f64.powi(left.scale() as i32);
     let array = arith_decimal_scalar(left, right, |left, right| {
         let l_value = left as f64;
@@ -615,34 +621,66 @@ mod tests {
         assert_eq!(expect, result);
         // divide
         let left_decimal_array = create_decimal_array(
-            &[Some(1234567), None, Some(1234567), Some(1234567)],
+            &[
+                Some(1234567),
+                None,
+                Some(1234567),
+                Some(1234567),
+                Some(1234567),
+            ],
+            25,
+            3,
+        );
+        let right_decimal_array = create_decimal_array(
+            &[Some(10), Some(100), Some(55), Some(-123), None],
             25,
             3,
         );
-        let right_decimal_array =
-            create_decimal_array(&[Some(10), Some(100), Some(55), Some(-123)], 25, 3);
         let result = divide_decimal(&left_decimal_array, &right_decimal_array)?;
         let expect = create_decimal_array(
-            &[Some(123456700), None, Some(22446672), Some(-10037130)],
+            &[Some(123456700), None, Some(22446672), Some(-10037130), None],
             25,
             3,
         );
         assert_eq!(expect, result);
         let result = divide_decimal_scalar(&left_decimal_array, 10)?;
         let expect = create_decimal_array(
-            &[Some(123456700), None, Some(123456700), Some(123456700)],
+            &[
+                Some(123456700),
+                None,
+                Some(123456700),
+                Some(123456700),
+                Some(123456700),
+            ],
             25,
             3,
         );
         assert_eq!(expect, result);
         // modulus
         let result = modulus_decimal(&left_decimal_array, &right_decimal_array)?;
-        let expect = create_decimal_array(&[Some(7), None, Some(37), Some(16)], 25, 3);
+        let expect =
+            create_decimal_array(&[Some(7), None, Some(37), Some(16), None], 25, 3);
         assert_eq!(expect, result);
         let result = modulus_decimal_scalar(&left_decimal_array, 10)?;
-        let expect = create_decimal_array(&[Some(7), None, Some(7), Some(7)], 25, 3);
+        let expect =
+            create_decimal_array(&[Some(7), None, Some(7), Some(7), Some(7)], 25, 3);
         assert_eq!(expect, result);
 
         Ok(())
     }
+
+    #[test]
+    fn arithmetic_decimal_divide_by_zero() {
+        let left_decimal_array = create_decimal_array(&[Some(101)], 10, 1);
+        let right_decimal_array = create_decimal_array(&[Some(0)], 1, 1);
+
+        let err = divide_decimal(&left_decimal_array, &right_decimal_array).unwrap_err();
+        assert_eq!("Arrow error: Divide by zero error", err.to_string());
+        let err = divide_decimal_scalar(&left_decimal_array, 0).unwrap_err();
+        assert_eq!("Arrow error: Divide by zero error", err.to_string());
+        let err = modulus_decimal(&left_decimal_array, &right_decimal_array).unwrap_err();
+        assert_eq!("Arrow error: Divide by zero error", err.to_string());
+        let err = modulus_decimal_scalar(&left_decimal_array, 0).unwrap_err();
+        assert_eq!("Arrow error: Divide by zero error", err.to_string());
+    }
 }