Function case_conversion_ascii_array

datafusion/functions/src/string/common.rs:581–614

Fast path for case conversion on an all-ASCII string array. ASCII case conversion is byte-length-preserving, so we can convert the entire addressed byte range in one pass over the value buffer and reuse the offsets and nulls buffers — rebasing the offsets when the input is a sliced array.

(
    string_array: &GenericStringArray<O>,
    lower: bool,
)

/// byte range in one pass over the value buffer and reuse the offsets and nulls
/// buffers — rebasing the offsets when the input is a sliced array.
fn case_conversion_ascii_array<O: OffsetSizeTrait>(
    string_array: &GenericStringArray<O>,
    lower: bool,
) -> Result<ArrayRef> {
    let value_offsets = string_array.value_offsets();
    let start = value_offsets.first().unwrap().as_usize();
    let end = value_offsets.last().unwrap().as_usize();
    let relevant = &string_array.value_data()[start..end];

    let converted: Vec<u8> = if lower {
        relevant.iter().map(u8::to_ascii_lowercase).collect()
    } else {
        relevant.iter().map(u8::to_ascii_uppercase).collect()
    };
    let values = Buffer::from_vec(converted);

    // Shift offsets from `start`-based to 0-based so they index into `values`.
    let offsets = if start == 0 {
        string_array.offsets().clone()
    } else {
        let s = O::usize_as(start);
        let rebased: Vec<O> = value_offsets.iter().map(|&o| o - s).collect();
        // SAFETY: subtracting a constant from monotonic offsets preserves
        // monotonicity, and `start` is the minimum offset, so no underflow.
        unsafe { OffsetBuffer::new_unchecked(ScalarBuffer::from(rebased)) }
    };

    let nulls = string_array.nulls().cloned();
    // SAFETY: offsets are monotonic and in-bounds for `values`; nulls
    // (if any) match the slice length.
    Ok(Arc::new(unsafe {
        GenericStringArray::<O>::new_unchecked(offsets, values, nulls)
    }))
}