Function array_index

src/expr/src/scalar/func/variadic.rs:357–398

(
    &self,
    array: Array<'a, T>,
    indices: Variadic<i64>,
)

}
#[sqlfunc(ArrayIndex, sqlname = "array_index", introduces_nulls = true)]
fn array_index<'a, T: FromDatum<'a>>(
    &self,
    array: Array<'a, T>,
    indices: Variadic<i64>,
) -> Option<T> {
    mz_ore::soft_assert_no_log!(
        self.offset == 0 || self.offset == 1,
        "offset must be either 0 or 1"
    );

    let dims = array.dims();
    if dims.len() != indices.len() {
        // You missed the datums "layer"
        return None;
    }

    let mut final_idx = 0;

    for (d, idx) in dims.into_iter().zip_eq(indices.iter()) {
        // Lower bound is written in terms of 1-based indexing, which offset accounts for.
        let idx = isize::cast_from(*idx + self.offset);

        let (lower, upper) = d.dimension_bounds();

        // This index missed all of the data at this layer. The dimension bounds are inclusive,
        // while range checks are exclusive, so adjust.
        if !(lower..upper + 1).contains(&idx) {
            return None;
        }

        // We discover how many indices our last index represents physically.
        final_idx *= d.length;

        // Because both index and lower bound are handled in 1-based indexing, taking their
        // difference moves us back into 0-based indexing. Similarly, if the lower bound is
        // negative, subtracting a negative value >= to itself ensures its non-negativity.
        final_idx += usize::try_from(idx - d.lower_bound)
            .expect("previous bounds check ensures physical index is at least 0");
    }

    array.elements().typed_iter().nth(final_idx)
}

#[sqlfunc]
fn array_position<'a>(