Method from

arrow-array/src/array/dictionary_array.rs:588–627

(data: ArrayData)

/// Constructs a `DictionaryArray` from an `ArrayData`
impl<T: ArrowDictionaryKeyType> From<ArrayData> for DictionaryArray<T> {
    fn from(data: ArrayData) -> Self {
        let (data_type, len, nulls, offset, mut buffers, mut child_data) = data.into_parts();

        assert_eq!(
            buffers.len(),
            1,
            "DictionaryArray data should contain a single buffer only (keys)."
        );
        let buffer = buffers.pop().expect("checked above");
        assert_eq!(
            child_data.len(),
            1,
            "DictionaryArray should contain a single child array (values)."
        );
        let cd = child_data.pop().expect("checked above");

        if let DataType::Dictionary(key_data_type, _) = &data_type {
            assert_eq!(
                &T::DATA_TYPE,
                key_data_type.as_ref(),
                "DictionaryArray's data type must match, expected {} got {}",
                T::DATA_TYPE,
                key_data_type
            );

            let values = make_array(cd);

            // create a zero-copy of the keys' data
            let keys = PrimitiveArray::<T>::new(ScalarBuffer::new(buffer, offset, len), nulls);

            Self {
                data_type,
                keys,
                values,
                is_ordered: false,
            }
        } else {
            panic!("DictionaryArray must have Dictionary data type.")
        }
    }
}

impl<T: ArrowDictionaryKeyType> From<DictionaryArray<T>> for ArrayData {