Skip to content

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.rs
index 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.rs
index 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>
where
T: 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.rs
index 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 @@ where
R::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 i128
diff --git a/datafusion/sqllogictest/test_files/decimal.slt b/datafusion/sqllogictest/test_files/decimal.slt
index 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);
4
8.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 decimals
query 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 R
SELECT power(10, -2.0)