Fix regression for negative-scale decimal128 in log (#19315)

## Which issue does this PR close?

- Part of #19250 

## Rationale for this change

Previously, the `log` function would fail when operating on decimal
values with negative scales.

Negative scales in decimals represent values where the scale indicates
padding zeros to the right (e.g., `Decimal128(38, -2)` with value `100`
represents `10000`). This PR restores support for negative-scale
decimals in the `log` function by implementing the logarithmic property:
`log_base(value * 10^(-scale)) = log_base(value) + (-scale) *
log_base(10)`.

## What changes are included in this PR?

1. **Enhanced `log_decimal128` function**:
   - Added support for negative scales using the logarithmic property
- For negative scales, computes `log_base(value) + (-scale) *
log_base(10)` instead of trying to convert to unscaled value
- Added detection for negative-scale decimals in both the number and
base arguments
- Skips simplification when negative scales are detected to avoid errors
with `ScalarValue` (which doesn't support negative scales yet)
  
2. **Added comprehensive tests**:
- Unit tests in `log.rs` for negative-scale decimals with various bases
(2, 3, 10)
- SQL logic tests in `decimal.slt` using scientific notation (e.g.,
`1e4`, `8e1`) to create decimals with negative scales

## Are these changes tested?

Yes, this PR includes comprehensive tests:

1. Unit tests:
- `test_log_decimal128_negative_scale`: Tests array inputs with negative
scales
- `test_log_decimal128_negative_scale_base2`: Tests with base 2 and
negative scales
- `test_log_decimal128_negative_scale_scalar`: Tests scalar inputs with
negative scales

2. SQL logic tests:
   - Tests for unary log with negative scales (`log(1e4)`)
   - Tests for binary log with explicit base 10 (`log(10, 1e4)`)
- Tests for binary log with base 2 (`log(2.0, 8e1)`, `log(2.0, 16e1)`)
   - Tests for different negative scale values (`log(5e3)`)
   - Tests for array operations with negative scales
   - Tests for different bases (2, 3, 10) with negative-scale decimals

All tests pass successfully.

## Are there any user-facing changes?

Yes, this is a user-facing change:

**Before**: The `log` function would fail with an error when operating
on decimal values with negative scales:
```sql
-- This would fail
SELECT log(1e4);  -- Error: Negative scale is not supported
```

**After**: The `log` function now correctly handles decimal values with
negative scales:
```sql
-- This now works
SELECT log(1e4);  -- Returns 4.0 (log10(10000))
SELECT log(2.0, 8e1);  -- Returns ~6.32 (log2(80))
```

---------

Co-authored-by: Jeffrey Vo <[email protected]>
Co-authored-by: Martin Grigorov <[email protected]>

Author: 3 people

datafusion/functions/src/math/log.rs

@@ -166,13 +166,18 @@ fn log_decimal128(value: i128, scale: i8, base: f64) -> Result<f64, ArrowError>
         )));
     }
 
-    let unscaled_value = decimal128_to_i128(value, scale)?;
-    if unscaled_value > 0 {
+    if value <= 0 {
+        // Reflect f64::log behaviour
+        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 = decimal128_to_i128(value, scale)?;
         let log_value: u32 = unscaled_value.ilog(base as i128);
         Ok(log_value as f64)
-    } else {
-        // Reflect f64::log behaviour
-        Ok(f64::NAN)
     }
 }
 
@@ -342,6 +347,19 @@ impl ScalarUDFImpl for LogFunc {
         if num_args != 1 && num_args != 2 {
             return plan_err!("Expected log to have 1 or 2 arguments, got {num_args}");
         }
+
+        match arg_types.last().unwrap() {
+            DataType::Decimal32(_, scale)
+            | DataType::Decimal64(_, scale)
+            | DataType::Decimal128(_, scale)
+            | DataType::Decimal256(_, scale)
+                if *scale < 0 =>
+            {
+                return Ok(ExprSimplifyResult::Original(args));
+            }
+            _ => (),
+        };
+
         let number = args.pop().unwrap();
         let number_datatype = arg_types.pop().unwrap();
         // default to base 10

datafusion/sqllogictest/test_files/decimal.slt

@@ -918,6 +918,57 @@ select log(2.0, null);
 ----
 NULL
 
+# log with negative scale decimals
+# Using scientific notation to create decimals with negative scales
+# 1e4 = 10000 with scale -4, log10(10000) = 4.0
+query R
+select log(1e4);
+----
+4
+
+# log with negative scale and explicit base 10
+query R
+select log(10, 1e4);
+----
+4
+
+# log with negative scale and base 2
+# 8e1 = 80 with scale -1, log2(80) ≈ 6.321928
+query R
+select log(2.0, 8e1);
+----
+6.321928094887
+
+# log with negative scale and base 2 (another value)
+# 16e1 = 160 with scale -1, log2(160) ≈ 7.321928
+query R
+select log(2.0, 16e1);
+----
+7.321928094887
+
+# log with negative scale -3
+# 5e3 = 5000 with scale -3, log10(5000) ≈ 3.69897
+query R
+select log(5e3);
+----
+3.698970004336
+
+# log with negative scale array values
+query R rowsort
+select log(value) from (values (1e3), (1e4), (1e5)) as t(value);
+----
+3
+4
+5
+
+# log with negative scale and different bases
+query R rowsort
+select log(base, 1e4) from (values (10.0), (2.0), (3.0)) as t(base);
+----
+13.287712379549
+4
+8.383613097158
+
 # power with decimals
 
 query RT