Method invoke_with_args

datafusion/functions/src/string/concat_ws.rs:116–378

Concatenates all but the first argument, with separators. The first argument is used as the separator string, and should not be NULL. Other NULL arguments are ignored. concat_ws(',', 'abcde', 2, NULL, 22) = 'abcde,2,22'

(&self, args: ScalarFunctionArgs)

    /// NULL arguments are ignored.
    /// concat_ws(',', 'abcde', 2, NULL, 22) = 'abcde,2,22'
    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
        let ScalarFunctionArgs { args, .. } = args;

        if args.len() < 2 {
            return exec_err!(
                "concat_ws was called with {} arguments. It requires at least 2.",
                args.len()
            );
        }

        let return_datatype = if args.iter().any(|c| c.data_type() == DataType::Utf8View)
        {
            DataType::Utf8View
        } else if args.iter().any(|c| c.data_type() == DataType::LargeUtf8) {
            DataType::LargeUtf8
        } else {
            DataType::Utf8
        };

        let array_len = args.iter().find_map(|x| match x {
            ColumnarValue::Array(array) => Some(array.len()),
            _ => None,
        });

        // Scalar
        if array_len.is_none() {
            let ColumnarValue::Scalar(scalar) = &args[0] else {
                unreachable!()
            };
            let sep = match scalar.try_as_str() {
                Some(Some(s)) => s,
                Some(None) => {
                    // null literal string
                    return match return_datatype {
                        DataType::Utf8View => {
                            Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(None)))
                        }
                        DataType::LargeUtf8 => {
                            Ok(ColumnarValue::Scalar(ScalarValue::LargeUtf8(None)))
                        }
                        _ => Ok(ColumnarValue::Scalar(ScalarValue::Utf8(None))),
                    };
                }
                None => return internal_err!("Expected string literal, got {scalar:?}"),
            };

            let mut values = Vec::with_capacity(args.len() - 1);
            for arg in &args[1..] {
                let ColumnarValue::Scalar(scalar) = arg else {
                    unreachable!()
                };

                match scalar.try_as_str() {
                    Some(Some(v)) => values.push(v),
                    Some(None) => {} // null literal string
                    None => {
                        return internal_err!("Expected string literal, got {scalar:?}");
                    }