Function create_random_run_end_encoded_array

arrow/src/util/data_gen.rs:242–296

(
    index: &Field,
    value: &Field,
    size: usize,
    null_density: f32,
    true_density: f32,
)

}
#[inline]
fn create_random_run_end_encoded_array(
    index: &Field,
    value: &Field,
    size: usize,
    null_density: f32,
    true_density: f32,
) -> Result<ArrayRef> {
    const MIN_RUN: usize = 8;
    const MAX_RUN: usize = 32;

    let mut rng = seedable_rng();
    let mut run_lengths: Vec<usize> = Vec::new();
    let mut remaining = size;
    while remaining > 0 {
        let len = rng.random_range(MIN_RUN..=MAX_RUN).min(remaining);
        run_lengths.push(len);
        remaining -= len;
    }
    let num_runs = run_lengths.len();

    let mut cumulative: i64 = 0;
    let run_ends_i64: Vec<i64> = run_lengths
        .iter()
        .map(|&l| {
            cumulative += l as i64;
            cumulative
        })
        .collect();

    let values = create_random_array(value, num_runs, null_density, true_density)?;

    match index.data_type() {
        DataType::Int16 => {
            let run_ends: Int16Array = run_ends_i64.iter().map(|&v| v as i16).collect();
            Ok(Arc::new(RunArray::<Int16Type>::try_new(
                &run_ends, &values,
            )?))
        }
        DataType::Int32 => {
            let run_ends: Int32Array = run_ends_i64.iter().map(|&v| v as i32).collect();
            Ok(Arc::new(RunArray::<Int32Type>::try_new(
                &run_ends, &values,
            )?))
        }
        DataType::Int64 => {
            let run_ends: Int64Array = run_ends_i64.iter().copied().collect();
            Ok(Arc::new(RunArray::<Int64Type>::try_new(
                &run_ends, &values,
            )?))
        }
        other => Err(ArrowError::InvalidArgumentError(format!(
            "Unsupported run-ends type for REE: {other:?}"
        ))),
    }
}

#[inline]
fn create_random_list_array(