test: cover more log() coercion paths and document the type change

Add integer, decimal, dictionary, and NULL cases to the coercion test, a
Float32 typed NULL to the simplify test, and Float16/Float32 and NULL/NULL
SQL cases. Add an upgrade guide entry for the log() result type change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: U0001F3A2

datafusion/functions/src/math/log.rs

@@ -776,15 +776,25 @@ mod tests {
     fn test_log_simplify_typed_null() {
         // Coercion can turn a NULL argument into a typed NULL literal
         let context = SimplifyContext::default();
-        for args in [
-            vec![lit(ScalarValue::Float64(None)), lit(2.0)],
-            vec![lit(2.0), lit(ScalarValue::Float64(None))],
+        for (args, expected) in [
+            (
+                vec![lit(ScalarValue::Float64(None)), lit(2.0)],
+                ScalarValue::Float64(None),
+            ),
+            (
+                vec![lit(2.0), lit(ScalarValue::Float64(None))],
+                ScalarValue::Float64(None),
+            ),
+            (
+                vec![lit(ScalarValue::Float32(None)), lit(2.0f32)],
+                ScalarValue::Float32(None),
+            ),
         ] {
             let result = LogFunc::new().simplify(args, &context).unwrap();
             let ExprSimplifyResult::Simplified(expr) = result else {
                 panic!("Expected ExprSimplifyResult::Simplified")
             };
-            assert_eq!(expr, lit(ScalarValue::Float64(None)));
+            assert_eq!(expr, lit(expected));
         }
     }
 
@@ -1271,6 +1281,12 @@ mod tests {
         assert_eq!(coerce(&[Float32, Float16]), [Float32, Float32]);
         assert_eq!(coerce(&[Float16, Float64]), [Float64, Float64]);
         assert_eq!(coerce(&[Int64, Float32]), [Float64, Float64]);
+        assert_eq!(coerce(&[Float32, Int64]), [Float64, Float64]);
+        assert_eq!(coerce(&[Decimal128(10, 2), Float32]), [Float64, Float64]);
+        assert_eq!(
+            coerce(&[Float64, Dictionary(Box::new(Int32), Box::new(Float32))]),
+            [Float64, Float64]
+        );
         // Homogeneous inputs keep their type
         assert_eq!(coerce(&[Float16, Float16]), [Float16, Float16]);
         assert_eq!(coerce(&[Float32, Float32]), [Float32, Float32]);
@@ -1282,5 +1298,10 @@ mod tests {
             [Float32, Decimal128(10, 2)]
         );
         assert_eq!(coerce(&[Decimal128(10, 2)]), [Decimal128(10, 2)]);
+        // A NULL base is typed by the value; a NULL value matches the decimal
+        // value signature and stays untyped
+        assert_eq!(coerce(&[Null, Float32]), [Float32, Float32]);
+        assert_eq!(coerce(&[Float32, Null]), [Float32, Null]);
+        assert_eq!(coerce(&[Null, Null]), [Null, Null]);
     }
 }

datafusion/sqllogictest/test_files/math.slt

@@ -1339,6 +1339,12 @@ SELECT log(2.5::float, 10.9::float), arrow_typeof(log(2.5::float, 10.9::float));
 ----
 2.606992 Float32
 
+# A Float16 base is widened to a Float32 value's type
+query RT
+SELECT log(arrow_cast(2.5, 'Float16'), 10.9::float), arrow_typeof(log(arrow_cast(2.5, 'Float16'), 10.9::float));
+----
+2.606992 Float32
+
 # #22581: a Float64 base must keep full precision against a Float32 value.
 # 16777217 is not representable in Float32, so an f32 computation would round it.
 query RT
@@ -1357,6 +1363,11 @@ SELECT log(NULL, 2.0::float), arrow_typeof(log(NULL, 2.0::float));
 ----
 NULL Float32
 
+query RT
+SELECT log(NULL, NULL), arrow_typeof(log(NULL, NULL));
+----
+NULL Float64
+
 # A Float16 base is widened to a wider value's type
 query RT
 SELECT log(arrow_cast(2.5, 'Float16'), 1.0::double), arrow_typeof(log(arrow_cast(2.5, 'Float16'), 1.0::double));

docs/source/library-user-guide/upgrading/56.0.0.md

@@ -684,6 +684,25 @@ value of the stride instead. See [issue #25856] for details.
 [postgresql]: https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-BIN
 [issue #25856]: https://github.com/apache/datafusion/issues/25856
 
+### `log(base, value)` widens float arguments to the wider type
+
+`log(base, value)` previously computed in the float type of `value`, so a
+wider `base` was narrowed and lost precision. Both arguments are now widened to
+the wider float type, and the result has that type. An integer or decimal
+`base` counts as `Float64`.
+
+```sql
+-- Before: 0.041666668 (Float32)
+-- After:  0.041666666517376175 (Float64)
+SELECT log(arrow_cast(16777217, 'Float64'), arrow_cast(2.0, 'Float32'));
+```
+
+Calls whose arguments have the same float type, and calls with a decimal
+`value`, are unchanged. Wrap the call in `CAST` to keep the previous result
+type. See [issue #22581] for details.
+
+[issue #22581]: https://github.com/apache/datafusion/issues/22581
+
 ### `DataFrame::from_columns` accepts `IntoIterator`
 
 `DataFrame::from_columns` now accepts any `IntoIterator<Item = (&str, ArrayRef)>`