Function generate_dict

benchmarks/src/dict.rs:259–311

(
    value_type: DictValueType,
    cardinality: Cardinality,
    null_percent: NullPercent,
    size: usize,
)

];

pub fn generate_dict(
    value_type: DictValueType,
    cardinality: Cardinality,
    null_percent: NullPercent,
    size: usize,
) -> ArrayRef {
    let num_distinct = cardinality.num_distinct(size);

    let dict_values: ArrayRef = match value_type {
        DictValueType::Utf8 => {
            let strings: StringArray = (0..num_distinct)
                .map(|i| format!("value_{i}"))
                .collect::<Vec<_>>()
                .into();
            Arc::new(strings)
        }
        DictValueType::ListUtf8 => {
            let flat: StringArray = (0..num_distinct)
                .flat_map(|i| (0..ITEMS_PER_VALUE).map(move |j| format!("value_{i}_{j}")))
                .collect::<Vec<_>>()
                .into();

            let offsets: Vec<i32> = (0..=(num_distinct * ITEMS_PER_VALUE))
                .step_by(ITEMS_PER_VALUE)
                .map(|o| o as i32)
                .collect();

            Arc::new(ListArray::new(
                Arc::new(Field::new("item", DataType::Utf8, false)),
                OffsetBuffer::new(offsets.into()),
                Arc::new(flat),
                None,
            ))
        }
    };

    let null_every = null_percent.null_every();

    let mut key_builder = Int32Array::builder(size);
    for i in 0..size {
        if null_every.is_some_and(|n| i % n == 0) {
            key_builder.append_null();
        } else {
            key_builder.append_value((i % num_distinct) as i32);
        }
    }
    let keys = key_builder.finish();

    Arc::new(
        DictionaryArray::<Int32Type>::try_new(keys, dict_values)
            .expect("valid dictionary array"),
    )
}
impl RunOpt {
    pub async fn run(self) -> Result<()> {
        println!(