How to use builders in a loop to build array of lists of structs?

[ryansun96]

I'm trying to use a loop to build an array of lists of structs, but have been stuck with mutable borrow issues:

let mut list_builder = ListBuilder::new(StructBuilder::from_fields(FieldsOfKeyAndValue, 0));
let struct_builder = list_builder.values();

// let key_builder = struct_builder.field_builder::<StringBuilder>(0).unwrap(); //Cannot do this due to only one mutable borrow allowed at a time;
// have to use workaround below
// let value_builder = struct_builder.field_builder::<StringBuilder>(1).unwrap();
let (field_builder_key, field_builder_value) = struct_builder.field_builders_mut().split_at_mut(1);
let key_builder = field_builder_key[0].as_any_mut().downcast_mut::<StringBuilder>().unwrap();
let value_builder = field_builder_value[0].as_any_mut().downcast_mut::<StringBuilder>().unwrap();

for (k, v) in Map:
    key_builder.append_value(k);
    value_builder.append_value(v);
    struct_builder.append(true); // Compiler complains struct_builder and list_builder have more than one mutable borrows
    list_builder.append(true);
list_builder.finish()

I have seen chained calls being used elsewhere (e.g. https://github.com/apache/datafusion/blob/33b86fe02e7bbe63135995c2dbb47bf83c08143c/datafusion/core/tests/dataframe/mod.rs#L5211), however this would become very lengthy and unreadable for complex structures, like the one in https://docs.rs/arrow/latest/arrow/array/struct.StructBuilder.html . Is there a better way to avoid the multiple mut borrow issue?

for _ in 0..num_points.max(2) {
                // Add x value
                points_builder
                    .values()
                    .field_builder::<Int32Builder>(0)
                    .unwrap()
                    .append_value(rng.random_range(-10..10));
                // Add y value
                points_builder
                    .values()
                    .field_builder::<Int32Builder>(1)
                    .unwrap()
                    .append_value(rng.random_range(-10..10));
                points_builder.values().append(true);

[ryux1]

The simplest pattern is to keep each mutable borrow shorter than the next builder operation. A small helper makes that explicit and avoids repeating the chained calls:

fn append_entry(builder: &mut StructBuilder, key: &str, value: &str) {
    {
        let (key_fields, value_fields) =
            builder.field_builders_mut().split_at_mut(1);

        key_fields[0]
            .as_any_mut()
            .downcast_mut::<StringBuilder>()
            .unwrap()
            .append_value(key);

        value_fields[0]
            .as_any_mut()
            .downcast_mut::<StringBuilder>()
            .unwrap()
            .append_value(value);
    } // the child-builder borrows end here

    builder.append(true);
}

let mut list_builder =
    ListBuilder::new(StructBuilder::from_fields(fields_of_key_and_value, 0));

for map in maps {
    for (key, value) in map {
        append_entry(list_builder.values(), key, value);
    }

    // One list slot per map / outer row, not one per key-value struct.
    list_builder.append(true);
}

let array = list_builder.finish();

There are two separate borrow conflicts in the original code:

1. Holding key_builder / value_builder keeps struct_builder mutably borrowed, so struct_builder.append(true) cannot run until those references leave scope.
2. Holding struct_builder = list_builder.values() keeps list_builder borrowed, so list_builder.append(true) must happen after that borrow ends.

The helper handles both: list_builder.values() is borrowed only for the call, and the inner scope releases the two field builders before appending the struct validity bit.

Also, each struct row must append exactly one value (or null) to every child builder before StructBuilder::append; that consistency is required by the builder contract: current source.