Method invoke_with_args

datafusion/functions/src/string/repeat.rs:99–156

(&self, args: ScalarFunctionArgs)

    }

    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
        let return_type = args.return_field.data_type().clone();
        let [string_arg, count_arg] = take_function_args(self.name(), args.args)?;

        // Early return if either argument is a scalar null
        if let ColumnarValue::Scalar(s) = &string_arg
            && s.is_null()
        {
            return Ok(ColumnarValue::Scalar(ScalarValue::try_from(&return_type)?));
        }
        if let ColumnarValue::Scalar(c) = &count_arg
            && c.is_null()
        {
            return Ok(ColumnarValue::Scalar(ScalarValue::try_from(&return_type)?));
        }

        match (&string_arg, &count_arg) {
            (
                ColumnarValue::Scalar(string_scalar),
                ColumnarValue::Scalar(count_scalar),
            ) => {
                let count = match count_scalar {
                    ScalarValue::Int64(Some(n)) => *n,
                    _ => {
                        return internal_err!(
                            "Unexpected data type {:?} for repeat count",
                            count_scalar.data_type()
                        );
                    }
                };

                let result = match string_scalar {
                    ScalarValue::Utf8View(Some(s)) => ScalarValue::Utf8View(Some(
                        compute_repeat(s, count, i32::MAX as usize)?,
                    )),
                    ScalarValue::Utf8(Some(s)) => ScalarValue::Utf8(Some(
                        compute_repeat(s, count, i32::MAX as usize)?,
                    )),
                    ScalarValue::LargeUtf8(Some(s)) => ScalarValue::LargeUtf8(Some(
                        compute_repeat(s, count, i64::MAX as usize)?,
                    )),
                    _ => {
                        return internal_err!(
                            "Unexpected data type {:?} for function repeat",
                            string_scalar.data_type()
                        );
                    }
                };

                Ok(ColumnarValue::Scalar(result))
            }
            _ => {
                let string_array = string_arg.to_array(args.number_rows)?;
                let count_array = count_arg.to_array(args.number_rows)?;
                Ok(ColumnarValue::Array(repeat(&string_array, &count_array)?))
            }
        }
    }