Function case_conversion

datafusion/functions/src/string/common.rs:345–408

(
    args: &[ColumnarValue],
    lower: bool,
    name: &str,
)

}

fn case_conversion(
    args: &[ColumnarValue],
    lower: bool,
    name: &str,
) -> Result<ColumnarValue> {
    match &args[0] {
        ColumnarValue::Array(array) => match array.data_type() {
            DataType::Utf8 => Ok(ColumnarValue::Array(case_conversion_array::<i32>(
                array, lower,
            )?)),
            DataType::LargeUtf8 => Ok(ColumnarValue::Array(
                case_conversion_array::<i64>(array, lower)?,
            )),
            DataType::Utf8View => {
                let string_array = as_string_view_array(array)?;
                if string_array.is_ascii() {
                    return Ok(ColumnarValue::Array(Arc::new(
                        case_conversion_utf8view_ascii(string_array, lower),
                    )));
                }
                let item_len = string_array.len();
                // Null-preserving: reuse the input null buffer as the output null buffer.
                let nulls = string_array.nulls().cloned();
                let mut builder = StringViewArrayBuilder::with_capacity(item_len);

                if let Some(ref n) = nulls {
                    for i in 0..item_len {
                        if n.is_null(i) {
                            builder.append_placeholder();
                        } else {
                            // SAFETY: `n.is_null(i)` was false in the branch above.
                            let s = unsafe { string_array.value_unchecked(i) };
                            builder.append_value(&unicode_case(s, lower));
                        }
                    }
                } else {
                    for i in 0..item_len {
                        // SAFETY: no null buffer means every index is valid.
                        let s = unsafe { string_array.value_unchecked(i) };
                        builder.append_value(&unicode_case(s, lower));
                    }
                }

                Ok(ColumnarValue::Array(Arc::new(builder.finish(nulls)?)))
            }
            other => exec_err!("Unsupported data type {other:?} for function {name}"),
        },
        ColumnarValue::Scalar(scalar) => match scalar {
            ScalarValue::Utf8(a) => {
                let result = a.as_ref().map(|x| unicode_case(x, lower));
                Ok(ColumnarValue::Scalar(ScalarValue::Utf8(result)))
            }
            ScalarValue::LargeUtf8(a) => {
                let result = a.as_ref().map(|x| unicode_case(x, lower));
                Ok(ColumnarValue::Scalar(ScalarValue::LargeUtf8(result)))
            }
            ScalarValue::Utf8View(a) => {
                let result = a.as_ref().map(|x| unicode_case(x, lower));