Comment cleanup

Author: neilconway

datafusion/functions/src/math/power.rs

@@ -370,8 +370,6 @@ fn pow_decimal256_float_fallback(
 
 /// Compute `power(decimal_base, float_exponent)` by casting the base to
 /// `Float64` and running `pow` in float space; returns `Float64`.
-/// `calculate_binary_math` casts the exponent internally and preserves
-/// scalar shape, so we only need to materialize the base here.
 fn pow_decimal_via_float64(
     base: &ColumnarValue,
     exponent: &ColumnarValue,
@@ -399,11 +397,9 @@ impl ScalarUDFImpl for PowerFunc {
 
     fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
         // Return type as a function of (base, exponent). After signature
-        // coercion the operands are one of three shapes, plus a NULL on
-        // either side when an operand is a literal NULL:
+        // coercion, we have to handle the following cases:
         //
-        //   - NULL on either side -> Float64 (matches the other math
-        //     UDFs, which all return Float64 for NULL input)
+        //   - NULL on either side -> Float64 (typed NULL)
         //   - (Decimal, Float64)  -> Float64
         //   - (Decimal, Int64)    -> the base's Decimal type
         //   - (Float64, Float64)  -> Float64
@@ -424,8 +420,8 @@ impl ScalarUDFImpl for PowerFunc {
     fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
         let [base, exponent] = take_function_args(self.name(), &args.args)?;
 
-        // No native kernel exists for `(Decimal, Float64)`; bridge via
-        // Float64. The match below handles the remaining coerced shapes.
+        // No native kernel exists for `(Decimal, Float64)`; bridge by casting
+        // the base to Float64.
         if base.data_type().is_decimal() && exponent.data_type().is_floating() {
             return pow_decimal_via_float64(base, exponent, args.number_rows);
         }

datafusion/sqllogictest/test_files/decimal.slt

@@ -1118,11 +1118,6 @@ SELECT power(2.5::decimal(38, 3), 4), arrow_typeof(power(2.5::decimal(38, 3), 4)
 ----
 39.062 Decimal128(38, 3)
 
-# `power(decimal, float)` returns Float64: the result can grow beyond the
-# base's Decimal precision (e.g. `2.5 ^ 4.0 = 39.0625` does not fit in
-# `Decimal128(2, 1)`), so the function widens to Float64 instead of
-# silently truncating. Inf / NaN are representable in Float64, so the
-# edge cases below succeed rather than erroring on Decimal cast.
 query RT
 SELECT power(2.5, 4.0), arrow_typeof(power(2.5, 4.0));
 ----

datafusion/sqllogictest/test_files/math.slt

@@ -818,9 +818,9 @@ from values
 81
 NULL
 
-# `power` accepts (Decimal, Int), (Decimal, Float), or (Float, Float) -- there
-# is no form that takes a Decimal exponent. So a Decimal exponent coerces to
-# Float64, and `power(decimal, float)` returns Float64.
+# There is no variant of `power` that accepts (Decimal, Decimal); type coercion
+# will cast the exponent to `Float64`, and `power(decimal, float)` returns
+# `Float64`.
 query RT rowsort
 select
   power(base::decimal(38, 0), exponent::decimal(38, 0)),