Method invoke_with_args

datafusion/functions/src/math/log.rs:232–305

Support overloaded log(base, x) and log(x) which defaults to log(10, x)

(&self, args: ScalarFunctionArgs)

    // Support overloaded log(base, x) and log(x) which defaults to log(10, x)
    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
        if args.arg_fields.iter().any(|a| a.data_type().is_null()) {
            return ColumnarValue::Scalar(ScalarValue::Null)
                .cast_to(args.return_type(), None);
        }

        let (base, value) = if args.args.len() == 2 {
            (args.args[0].clone(), &args.args[1])
        } else {
            // no base specified, default to 10
            (
                ColumnarValue::Scalar(ScalarValue::new_ten(args.return_type())?),
                &args.args[0],
            )
        };
        let value = value.to_array(args.number_rows)?;

        let output: ArrayRef = match value.data_type() {
            DataType::Float16 => {
                calculate_binary_math::<Float16Type, Float16Type, Float16Type, _>(
                    &value,
                    &base,
                    |value, base| Ok(value.log(base)),
                )?
            }
            DataType::Float32 => {
                calculate_binary_math::<Float32Type, Float32Type, Float32Type, _>(
                    &value,
                    &base,
                    |value, base| Ok(value.log(base)),
                )?
            }
            DataType::Float64 => {
                calculate_binary_math::<Float64Type, Float64Type, Float64Type, _>(
                    &value,
                    &base,
                    |value, base| Ok(value.log(base)),
                )?
            }
            DataType::Decimal32(_, scale) => {
                calculate_binary_math::<Decimal32Type, Float64Type, Float64Type, _>(
                    &value,
                    &base,
                    |value, base| log_decimal32(value, *scale, base),
                )?
            }
            DataType::Decimal64(_, scale) => {
                calculate_binary_math::<Decimal64Type, Float64Type, Float64Type, _>(
                    &value,
                    &base,
                    |value, base| log_decimal64(value, *scale, base),
                )?
            }
            DataType::Decimal128(_, scale) => {
                calculate_binary_math::<Decimal128Type, Float64Type, Float64Type, _>(
                    &value,
                    &base,
                    |value, base| log_decimal128(value, *scale, base),