Function get_true_start_end

datafusion/functions/src/unicode/substr.rs:170–222

Convert the given `start` and `count` to valid byte indices within `input` string. Input `start` and `count` are equivalent to PostgreSQL's `substr(s, start, count)`. `start` is 1-based; if `count` is not provided, returns indices to the end of the string. Input indices are character-based, and return values are byte indices. The input bounds can be outside string bounds; this function will retur

(
    input: &str,
    start: i64,
    count: Option<i64>,
    is_input_ascii_only: bool,
)

/// get_true_start_end('Hi🌏', -10, Some(2)) -> Ok((0, 0))
/// ```
pub fn get_true_start_end(
    input: &str,
    start: i64,
    count: Option<i64>,
    is_input_ascii_only: bool,
) -> Result<(usize, usize)> {
    if let Some(count) = count
        && count < 0
    {
        return exec_err!("negative count not allowed: {count}");
    }

    // The caller-provided `start` is 1-indexed.
    let Some(start) = start.checked_sub(1) else {
        return exec_err!("start position overflow: {start}");
    };

    let end = match count {
        Some(count) => start.saturating_add(count),
        None => input.len() as i64,
    };

    let start = start.clamp(0, input.len() as i64) as usize;
    let end = end.clamp(0, input.len() as i64) as usize;

    // If input is ASCII-only, byte-based indices equal char-based indices
    if is_input_ascii_only {
        return Ok((start, end));
    }

    // Otherwise, calculate byte indices from char indices.  We initialize both
    // `byte_start` and `byte_end` to the string length to handle cases where
    // the requested 'start' or 'end' positions are at or beyond the end of the
    // string (resulting in an empty substring).
    let mut byte_start = input.len();
    let mut byte_end = input.len();

    for (char_idx, (byte_idx, _)) in input.char_indices().enumerate() {
        if char_idx == start {
            byte_start = byte_idx;
            // If no length is specified, we only need the start offset.
            if count.is_none() {
                break;
            }
        }
        if char_idx == end {
            byte_end = byte_idx;
            break;
        }
    }

    Ok((byte_start, byte_end))
}

// String characters are variable length encoded in UTF-8, `substr()` function's
// arguments are character-based, converting them into byte-based indices