Function array_fill

src/expr/src/scalar/func/variadic.rs:248–339

(
    &self,
    fill: Datum<'a>,
    dims: Option<Array<'a>>,
    lower_bounds: OptionalArg<Option<Array<'a>>>,
    temp_storage: &'a RowArena,
)

    introduces_nulls = false
)]
fn array_fill<'a>(
    &self,
    fill: Datum<'a>,
    dims: Option<Array<'a>>,
    lower_bounds: OptionalArg<Option<Array<'a>>>,
    temp_storage: &'a RowArena,
) -> Result<Datum<'a>, EvalError> {
    const MAX_SIZE: usize = (1 << 28) - 1;
    const NULL_ARR_ERR: &str = "dimension array or low bound array";
    const NULL_ELEM_ERR: &str = "dimension values";

    if matches!(fill, Datum::Array(_)) {
        return Err(EvalError::Unsupported {
            feature: "array_fill with arrays".into(),
            discussion_no: None,
        });
    }

    let Some(arr) = dims else {
        return Err(EvalError::MustNotBeNull(NULL_ARR_ERR.into()));
    };

    let dimensions = arr
        .elements()
        .iter()
        .map(|d| match d {
            Datum::Null => Err(EvalError::MustNotBeNull(NULL_ELEM_ERR.into())),
            d => Ok(usize::cast_from(u32::reinterpret_cast(d.unwrap_int32()))),
        })
        .collect::<Result<Vec<_>, _>>()?;

    let lower_bounds = match *lower_bounds {
        Some(d) => {
            let Some(arr) = d else {
                return Err(EvalError::MustNotBeNull(NULL_ARR_ERR.into()));
            };

            arr.elements()
                .iter()
                .map(|l| match l {
                    Datum::Null => Err(EvalError::MustNotBeNull(NULL_ELEM_ERR.into())),
                    l => Ok(isize::cast_from(l.unwrap_int32())),
                })
                .collect::<Result<Vec<_>, _>>()?
        }
        None => {
            vec![1isize; dimensions.len()]
        }
    };

    if lower_bounds.len() != dimensions.len() {
        return Err(EvalError::ArrayFillWrongArraySubscripts);
    }

    let fill_count: usize = dimensions
        .iter()
        .cloned()
        .map(Some)