Method from

arrow-array/src/array/union_array.rs:682–717

(data: ArrayData)

impl From<ArrayData> for UnionArray {
    fn from(data: ArrayData) -> Self {
        let (data_type, len, _nulls, offset, buffers, child_data) = data.into_parts();

        let (fields, mode) = match &data_type {
            DataType::Union(fields, mode) => (fields, mode),
            d => panic!("UnionArray expected ArrayData with type Union got {d}"),
        };

        let (type_ids, offsets) = match mode {
            UnionMode::Sparse => {
                let [buffer]: [Buffer; 1] = buffers.try_into().expect("1 buffer for type_ids");
                (ScalarBuffer::new(buffer, offset, len), None)
            }
            UnionMode::Dense => {
                let [type_ids_buffer, offsets_buffer]: [Buffer; 2] = buffers
                    .try_into()
                    .expect("2 buffers for type_ids and offsets");
                (
                    ScalarBuffer::new(type_ids_buffer, offset, len),
                    Some(ScalarBuffer::new(offsets_buffer, offset, len)),
                )
            }
        };

        let max_id = fields.iter().map(|(i, _)| i).max().unwrap_or_default() as usize;
        let mut boxed_fields = vec![None; max_id + 1];
        for (cd, (field_id, _)) in child_data.into_iter().zip(fields.iter()) {
            boxed_fields[field_id as usize] = Some(make_array(cd));
        }
        Self {
            data_type,
            type_ids,
            offsets,
            fields: boxed_fields,
        }
    }
}

impl From<UnionArray> for ArrayData {