Apache DataFusion SQL Query Engine
added support for negative scale for log decimal32/64 and power (#19409)
shifluxxca886b9eb4228
diff --git a/datafusion/functions/src/math/log.rs b/datafusion/functions/src/math/log.rsindex 33d43fa4fa..0c50afa2df 100644--- a/datafusion/functions/src/math/log.rs+++ b/datafusion/functions/src/math/log.rs@@ -118,13 +118,21 @@ fn log_decimal32(value: i32, scale: i8, base: f64) -> Result<f64, ArrowError> {)));}- let unscaled_value = decimal32_to_i32(value, scale)?;- if unscaled_value > 0 {+ // Match f64::log behaviour+ if value <= 0 {+ return Ok(f64::NAN);+ }++ if scale < 0 {+ let actual_value = (value as f64) * 10.0_f64.powi(-(scale as i32));+ Ok(actual_value.log(base))+ } else {+ let unscaled_value = decimal32_to_i32(value, scale)?;+ if unscaled_value <= 0 {+ return Ok(f64::NAN);+ }let log_value: u32 = unscaled_value.ilog(base as i32);Ok(log_value as f64)- } else {- // Reflect f64::log behaviour- Ok(f64::NAN)}}@@ -142,13 +150,20 @@ fn log_decimal64(value: i64, scale: i8, base: f64) -> Result<f64, ArrowError> {)));}- let unscaled_value = decimal64_to_i64(value, scale)?;- if unscaled_value > 0 {+ if value <= 0 {+ return Ok(f64::NAN);+ }++ if scale < 0 {+ let actual_value = (value as f64) * 10.0_f64.powi(-(scale as i32));+ Ok(actual_value.log(base))+ } else {+ let unscaled_value = decimal64_to_i64(value, scale)?;+ if unscaled_value <= 0 {+ return Ok(f64::NAN);+ }let log_value: u32 = unscaled_value.ilog(base as i64);Ok(log_value as f64)- } else {- // Reflect f64::log behaviour- Ok(f64::NAN)}}@@ -176,6 +191,9 @@ fn log_decimal128(value: i128, scale: i8, base: f64) -> Result<f64, ArrowError>Ok(actual_value.log(base))} else {let unscaled_value = decimal128_to_i128(value, scale)?;+ if unscaled_value <= 0 {+ return Ok(f64::NAN);+ }let log_value: u32 = unscaled_value.ilog(base as i128);Ok(log_value as f64)}diff --git a/datafusion/functions/src/math/power.rs b/datafusion/functions/src/math/power.rsindex 6b8eaa0be0..33166f6444 100644--- a/datafusion/functions/src/math/power.rs+++ b/datafusion/functions/src/math/power.rs@@ -118,33 +118,57 @@ fn pow_decimal_int<T>(base: T, scale: i8, exp: i64) -> Result<T, ArrowError>whereT: From<i32> + ArrowNativeTypeOp,{- let scale: u32 = scale.try_into().map_err(|_| {- ArrowError::NotYetImplemented(format!(- "Negative scale is not yet supported value: {scale}"- ))- })?;- if exp == 0 {- // Edge case to provide 1 as result (10^s with scale)- let result: T = T::from(10).pow_checked(scale).map_err(|_| {- ArrowError::ArithmeticOverflow(format!(- "Cannot make unscale factor for {scale} and {exp}"- ))- })?;- return Ok(result);- }let exp: u32 = exp.try_into().map_err(|_| {ArrowError::ArithmeticOverflow(format!("Unsupported exp value: {exp}"))})?;+ // Handle edge case for exp == 0+ // If scale < 0, 10^scale (e.g., 10^-2 = 0.01) becomes 0 in integer arithmetic.+ if exp == 0 {+ return if scale >= 0 {+ T::from(10).pow_checked(scale as u32).map_err(|_| {+ ArrowError::ArithmeticOverflow(format!(+ "Cannot make unscale factor for {scale} and {exp}"+ ))+ })+ } else {+ Ok(T::from(0))+ };+ }let powered: T = base.pow_checked(exp).map_err(|_| {ArrowError::ArithmeticOverflow(format!("Cannot raise base {base:?} to exp {exp}"))})?;- let unscale_factor: T = T::from(10).pow_checked(scale * (exp - 1)).map_err(|_| {- ArrowError::ArithmeticOverflow(format!(- "Cannot make unscale factor for {scale} and {exp}"- ))- })?;- powered.div_checked(unscale_factor)+ // Calculate the scale adjustment: s * (e - 1)+ // We use i64 to prevent overflow during the intermediate multiplication+ let mul_exp = (scale as i64).wrapping_mul(exp as i64 - 1);++ if mul_exp == 0 {+ return Ok(powered);+ }++ // If mul_exp is positive, we divide (standard case).+ // If mul_exp is negative, we multiply (negative scale case).+ if mul_exp > 0 {+ let div_factor: T = T::from(10).pow_checked(mul_exp as u32).map_err(|_| {+ ArrowError::ArithmeticOverflow(format!(+ "Cannot make div factor for {scale} and {exp}"+ ))+ })?;+ powered.div_checked(div_factor)+ } else {+ // mul_exp is negative, so we multiply by 10^(-mul_exp)+ let abs_exp = mul_exp.checked_neg().ok_or_else(|| {+ ArrowError::ArithmeticOverflow(+ "Overflow while negating scale exponent".to_string(),+ )+ })?;+ let mul_factor: T = T::from(10).pow_checked(abs_exp as u32).map_err(|_| {+ ArrowError::ArithmeticOverflow(format!(+ "Cannot make mul factor for {scale} and {exp}"+ ))+ })?;+ powered.mul_checked(mul_factor)+ }}/// Binary function to calculate a math power to float exponent@@ -387,9 +411,6 @@ mod tests {assert_eq!(pow_decimal_int(25, 0, 0).unwrap(), i128::from(1));assert_eq!(pow_decimal_int(25, 1, 0).unwrap(), i128::from(10));- assert_eq!(- pow_decimal_int(25, -1, 4).unwrap_err().to_string(),- "Not yet implemented: Negative scale is not yet supported value: -1"- );+ assert_eq!(pow_decimal_int(25, -1, 4).unwrap(), i128::from(390625000));}}diff --git a/datafusion/functions/src/utils.rs b/datafusion/functions/src/utils.rsindex e160eb68d5..e4980728b1 100644--- a/datafusion/functions/src/utils.rs+++ b/datafusion/functions/src/utils.rs@@ -19,7 +19,7 @@ use arrow::array::{Array, ArrayRef, ArrowPrimitiveType, AsArray, PrimitiveArray}use arrow::compute::try_binary;use arrow::datatypes::{DataType, DecimalType};use arrow::error::ArrowError;-use datafusion_common::{DataFusionError, Result, ScalarValue, not_impl_err};+use datafusion_common::{DataFusionError, Result, ScalarValue};use datafusion_expr::ColumnarValue;use datafusion_expr::function::Hint;use std::sync::Arc;@@ -189,16 +189,12 @@ whereR::Native: TryFrom<ScalarValue>,{let result_array = calculate_binary_math::<L, R, O, F>(left, right, fun)?;- if scale < 0 {- not_impl_err!("Negative scale is not supported for power for decimal types")- } else {- Ok(Arc::new(- result_array- .as_ref()- .clone()- .with_precision_and_scale(precision, scale)?,- ))- }+ Ok(Arc::new(+ result_array+ .as_ref()+ .clone()+ .with_precision_and_scale(precision, scale)?,+ ))}/// Converts Decimal128 components (value and scale) to an unscaled i128diff --git a/datafusion/sqllogictest/test_files/decimal.slt b/datafusion/sqllogictest/test_files/decimal.sltindex ccc27fa6cf..03b783b087 100644--- a/datafusion/sqllogictest/test_files/decimal.slt+++ b/datafusion/sqllogictest/test_files/decimal.slt@@ -969,6 +969,65 @@ select log(base, 1e4) from (values (10.0), (2.0), (3.0)) as t(base);48.383613097158+# log(decimal32) with negative scale+# 1e4 = 10000 with scale -4+query R+select log(CAST(1e4 AS DECIMAL(9, -4)));+----+4++# log(decimal32) with negative scale and base 2+# 8e1 = 80, log2(80) ≈ 6.321928+query R+select log(2.0, CAST(8e1 AS DECIMAL(9, -1)));+----+6.321928094887+++# log(decimal64) with negative scale+# 5e3 = 5000, log10(5000) ≈ 3.69897+query R+select log(CAST(5e3 AS DECIMAL(18, -3)));+----+3.698970004336++# log(decimal64) with negative scale and different bases+query R rowsort+select log(base, CAST(1e4 AS DECIMAL(18, -4)))+from (values (10.0), (2.0), (3.0)) as t(base);+----+13.287712379549+4+8.383613097158++# log(decimal128) with negative scale and base 2+# 8e1 = 80, log2(80) ≈ 6.321928+query R+select log(2.0, CAST(8e1 AS DECIMAL(38, -1)));+----+6.321928094887+++# log(decimal128) with negative scale and different bases+query R rowsort+select log(base, CAST(1e4 AS DECIMAL(38, -4)))+from (values (10.0), (2.0), (3.0)) as t(base);+----+13.287712379549+4+8.383613097158++# Test log of a decimal value between 0 and 1 (e.g., 0.5)+query R+SELECT log(10, arrow_cast(0.5, 'Decimal32(5, 1)'))+----+NaN++query R+SELECT log(10, arrow_cast(1 , 'Decimal32(5, 1)'))+----+0+# power with decimalsquery RT@@ -996,6 +1055,11 @@ SELECT power(2.5, 0)----1+query R+SELECT power(1e4, 2)+----+100000000+# int64 base with decimal exponent (coerced to float computation)query RSELECT power(10, -2.0)