Avoid clones in make_array for StructArray and GenericByteViewArray (#9114)

# Which issue does this PR close?


- Part of #9061
- broken out of #9058

# Rationale for this change

The current implementation of `make_array` for StructArray and
GenericByteViewArray clones `ArrayData` which allocates a new Vec. This
is unnecessary given that `make_array` is passed an owned ArrayData


# What changes are included in this PR?

1. Add a new API to ArrayData to break it down into parts (`into_parts`)
2. Use that API to avoid cloning while constructing StructArray and
GenericByteViewArray

# Are these changes tested?

Yes by CI

# Are there any user-facing changes?
A few fewer allocations when creating arrays

---------

Co-authored-by: Jeffrey Vo <jeffrey.vo.australia@gmail.com>

Author: alamb

arrow-array/src/array/byte_view_array.rs

@@ -967,15 +967,16 @@ impl<'a, T: ByteViewType + ?Sized> IntoIterator for &'a GenericByteViewArray<T>
 }
 
 impl<T: ByteViewType + ?Sized> From<ArrayData> for GenericByteViewArray<T> {
-    fn from(value: ArrayData) -> Self {
-        let views = value.buffers()[0].clone();
-        let views = ScalarBuffer::new(views, value.offset(), value.len());
-        let buffers = value.buffers()[1..].to_vec().into();
+    fn from(data: ArrayData) -> Self {
+        let (_data_type, len, nulls, offset, mut buffers, _child_data) = data.into_parts();
+        let views = buffers.remove(0); // need to maintain order of remaining buffers
+        let buffers = Arc::from(buffers);
+        let views = ScalarBuffer::new(views, offset, len);
         Self {
             data_type: T::DATA_TYPE,
             views,
             buffers,
-            nulls: value.nulls().cloned(),
+            nulls,
             phantom: Default::default(),
         }
     }

arrow-array/src/array/struct_array.rs

@@ -347,25 +347,26 @@ impl StructArray {
 
 impl From<ArrayData> for StructArray {
     fn from(data: ArrayData) -> Self {
-        let parent_offset = data.offset();
-        let parent_len = data.len();
+        let (data_type, len, nulls, offset, _buffers, child_data) = data.into_parts();
 
-        let fields = data
-            .child_data()
-            .iter()
+        let parent_offset = offset;
+        let parent_len = len;
+
+        let fields = child_data
+            .into_iter()
             .map(|cd| {
                 if parent_offset != 0 || parent_len != cd.len() {
                     make_array(cd.slice(parent_offset, parent_len))
                 } else {
-                    make_array(cd.clone())
+                    make_array(cd)
                 }
             })
             .collect();
 
         Self {
-            len: data.len(),
-            data_type: data.data_type().clone(),
-            nulls: data.nulls().cloned(),
+            len,
+            data_type,
+            nulls,
             fields,
         }
     }

arrow-data/src/data.rs

@@ -309,6 +309,9 @@ impl ArrayData {
     ///
     /// Note: This is a low level API and most users of the arrow crate should create
     /// arrays using the builders found in [arrow_array](https://docs.rs/arrow-array)
+    /// or [`ArrayDataBuilder`].
+    ///
+    /// See also [`Self::into_parts`] to recover the fields
     pub fn try_new(
         data_type: DataType,
         len: usize,
@@ -351,6 +354,33 @@ impl ArrayData {
         Ok(new_self)
     }
 
+    /// Return the constituent parts of this ArrayData
+    ///
+    /// This is the inverse of [`ArrayData::try_new`].
+    ///
+    /// Returns `(data_type, len, nulls, offset, buffers, child_data)`
+    pub fn into_parts(
+        self,
+    ) -> (
+        DataType,
+        usize,
+        Option<NullBuffer>,
+        usize,
+        Vec<Buffer>,
+        Vec<ArrayData>,
+    ) {
+        let Self {
+            data_type,
+            len,
+            nulls,
+            offset,
+            buffers,
+            child_data,
+        } = self;
+
+        (data_type, len, nulls, offset, buffers, child_data)
+    }
+
     /// Returns a builder to construct a [`ArrayData`] instance of the same [`DataType`]
     #[inline]
     pub const fn builder(data_type: DataType) -> ArrayDataBuilder {