expose shrink_to_fit to mutable arrays

src/array/binary/mutable.rs

@@ -135,6 +135,10 @@ impl<O: Offset> MutableBinaryArray<O> {
         let a: BinaryArray<O> = self.into();
         Arc::new(a)
     }
+    /// Shrinks the capacity of the [`MutableBinaryArray`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+    }
 }
 
 impl<O: Offset> MutableArray for MutableBinaryArray<O> {
@@ -180,6 +184,10 @@ impl<O: Offset> MutableArray for MutableBinaryArray<O> {
     fn push_null(&mut self) {
         self.push::<&[u8]>(None)
     }
+
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl<O: Offset, P: AsRef<[u8]>> FromIterator<Option<P>> for MutableBinaryArray<O> {

src/array/boolean/mutable.rs

@@ -370,6 +370,10 @@ impl MutableArray for MutableBooleanArray {
     fn push_null(&mut self) {
         self.push(None)
     }
+
+    fn shrink_to_fit(&mut self) {
+        // no-op still have to implement this for bitmaps
+    }
 }
 
 impl Extend<Option<bool>> for MutableBooleanArray {

src/array/dictionary/mutable.rs

@@ -104,6 +104,11 @@ impl<K: DictionaryKey, M: MutableArray> MutableDictionaryArray<K, M> {
         let a: DictionaryArray<K> = self.into();
         Arc::new(a)
     }
+
+    /// Shrinks the capacity of the [`MutableDictionaryArray`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+    }
 }
 
 impl<K: DictionaryKey, M: 'static + MutableArray> MutableArray for MutableDictionaryArray<K, M> {
@@ -144,6 +149,9 @@ impl<K: DictionaryKey, M: 'static + MutableArray> MutableArray for MutableDictio
     fn push_null(&mut self) {
         self.keys.push(None)
     }
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl<K, M, T: Hash> TryExtend<Option<T>> for MutableDictionaryArray<K, M>

src/array/fixed_size_binary/mutable.rs

@@ -149,6 +149,11 @@ impl MutableFixedSizeBinaryArray {
     pub unsafe fn value_unchecked(&self, i: usize) -> &[u8] {
         std::slice::from_raw_parts(self.values.as_ptr().add(i * self.size), self.size)
     }
+
+    /// Shrinks the capacity of the [`MutablePrimitive`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+    }
 }
 
 /// Accessors
@@ -204,6 +209,10 @@ impl MutableArray for MutableFixedSizeBinaryArray {
     fn push_null(&mut self) {
         self.values.extend_constant(self.size, 0);
     }
+
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl FixedSizeBinaryValues for MutableFixedSizeBinaryArray {

src/array/fixed_size_list/mutable.rs

@@ -58,6 +58,10 @@ impl<M: MutableArray> MutableFixedSizeListArray<M> {
                 .chain(std::iter::once(false)),
         ))
     }
+    /// Shrinks the capacity of the [`MutableFixedSizeList`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit()
+    }
 }
 
 impl<M: MutableArray + 'static> MutableArray for MutableFixedSizeListArray<M> {
@@ -107,6 +111,10 @@ impl<M: MutableArray + 'static> MutableArray for MutableFixedSizeListArray<M> {
             self.init_validity()
         }
     }
+
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl<T: NativeType> MutableFixedSizeListArray<MutablePrimitiveArray<T>> {

src/array/list/mutable.rs

@@ -40,6 +40,12 @@ impl<O: Offset, M: MutableArray + Default> MutableListArray<O, M> {
             validity: None,
         }
     }
+
+    /// Shrinks the capacity of the [`MutableList`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+        self.offsets.shrink_to_fit();
+    }
 }
 
 impl<O: Offset, M: MutableArray + Default> Default for MutableListArray<O, M> {
@@ -210,4 +216,7 @@ impl<O: Offset, M: MutableArray + 'static> MutableArray for MutableListArray<O,
     fn push_null(&mut self) {
         self.push_null()
     }
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit();
+    }
 }

src/array/mod.rs

@@ -151,6 +151,9 @@ pub trait MutableArray: std::fmt::Debug {
             .map(|x| x.get(index))
             .unwrap_or(true)
     }
+
+    /// Shrink the array to fit its length.
+    fn shrink_to_fit(&mut self);
 }
 
 macro_rules! general_dyn {

src/array/primitive/mutable.rs

@@ -237,6 +237,11 @@ impl<T: NativeType> MutablePrimitiveArray<T> {
         let a: PrimitiveArray<T> = self.into();
         Arc::new(a)
     }
+
+    /// Shrinks the capacity of the [`MutablePrimitive`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+    }
 }
 
 /// Accessors
@@ -357,6 +362,10 @@ impl<T: NativeType> MutableArray for MutablePrimitiveArray<T> {
     fn push_null(&mut self) {
         self.push(None)
     }
+
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl<T: NativeType + NaturalDataType> MutablePrimitiveArray<T> {

src/array/utf8/mutable.rs

@@ -164,6 +164,12 @@ impl<O: Offset> MutableUtf8Array<O> {
         let a: Utf8Array<O> = self.into();
         Arc::new(a)
     }
+
+    /// Shrinks the capacity of the [`MutableUtf8`] to fit its current length.
+    pub fn shrink_to_fit(&mut self) {
+        self.values.shrink_to_fit();
+        self.offsets.shrink_to_fit();
+    }
 }
 
 impl<O: Offset> MutableUtf8Array<O> {
@@ -224,6 +230,10 @@ impl<O: Offset> MutableArray for MutableUtf8Array<O> {
     fn push_null(&mut self) {
         self.push::<&str>(None)
     }
+
+    fn shrink_to_fit(&mut self) {
+        self.shrink_to_fit()
+    }
 }
 
 impl<O: Offset, P: AsRef<str>> FromIterator<Option<P>> for MutableUtf8Array<O> {