Add NullBuffer and BooleanBuffer From conversions

arrow-array/src/array/primitive_array.rs

@@ -294,16 +294,32 @@ impl<T: ArrowPrimitiveType> Clone for PrimitiveArray<T> {
 }
 
 impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
-    /// Create a new [`PrimitiveArray`] from the provided data_type, values, nulls
+    /// Create a new [`PrimitiveArray`] from the provided values and nulls
     ///
     /// # Panics
     ///
     /// Panics if [`Self::try_new`] returns an error
+    ///
+    /// # Example
+    ///
+    /// Creating a [`PrimitiveArray`] directly from a [`ScalarBuffer`] and [`NullBuffer`] using
+    /// this constructor is the most performant approach, avoiding any additional allocations
+    ///
+    /// ```
+    /// # use arrow_array::Int32Array;
+    /// # use arrow_array::types::Int32Type;
+    /// # use arrow_buffer::NullBuffer;
+    /// // [1, 2, 3, 4]
+    /// let array = Int32Array::new(vec![1, 2, 3, 4].into(), None);
+    /// // [1, null, 3, 4]
+    /// let nulls = NullBuffer::from(vec![true, false, true, true]);
+    /// let array = Int32Array::new(vec![1, 2, 3, 4].into(), Some(nulls));
+    /// ```
     pub fn new(values: ScalarBuffer<T::Native>, nulls: Option<NullBuffer>) -> Self {
         Self::try_new(values, nulls).unwrap()
     }
 
-    /// Create a new [`PrimitiveArray`] from the provided data_type, values, nulls
+    /// Create a new [`PrimitiveArray`] from the provided values and nulls
     ///
     /// # Errors
     ///

arrow-buffer/src/buffer/boolean.rs

@@ -18,8 +18,8 @@
 use crate::bit_chunk_iterator::BitChunks;
 use crate::bit_iterator::{BitIndexIterator, BitIterator, BitSliceIterator};
 use crate::{
-    bit_util, buffer_bin_and, buffer_bin_or, buffer_bin_xor, buffer_unary_not, Buffer,
-    MutableBuffer,
+    bit_util, buffer_bin_and, buffer_bin_or, buffer_bin_xor, buffer_unary_not,
+    BooleanBufferBuilder, Buffer, MutableBuffer,
 };
 use std::ops::{BitAnd, BitOr, BitXor, Not};
 
@@ -265,6 +265,30 @@ impl<'a> IntoIterator for &'a BooleanBuffer {
     }
 }
 
+impl From<&[bool]> for BooleanBuffer {
+    fn from(value: &[bool]) -> Self {
+        let mut builder = BooleanBufferBuilder::new(value.len());
+        builder.append_slice(value);
+        builder.finish()
+    }
+}
+
+impl From<Vec<bool>> for BooleanBuffer {
+    fn from(value: Vec<bool>) -> Self {
+        value.as_slice().into()
+    }
+}
+
+impl FromIterator<bool> for BooleanBuffer {
+    fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
+        let iter = iter.into_iter();
+        let (hint, _) = iter.size_hint();
+        let mut builder = BooleanBufferBuilder::new(hint);
+        iter.for_each(|b| builder.append(b));
+        builder.finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

arrow-buffer/src/buffer/null.rs

@@ -218,6 +218,30 @@ impl<'a> IntoIterator for &'a NullBuffer {
     }
 }
 
+impl From<BooleanBuffer> for NullBuffer {
+    fn from(value: BooleanBuffer) -> Self {
+        Self::new(value)
+    }
+}
+
+impl From<&[bool]> for NullBuffer {
+    fn from(value: &[bool]) -> Self {
+        BooleanBuffer::from(value).into()
+    }
+}
+
+impl From<Vec<bool>> for NullBuffer {
+    fn from(value: Vec<bool>) -> Self {
+        BooleanBuffer::from(value).into()
+    }
+}
+
+impl FromIterator<bool> for NullBuffer {
+    fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
+        BooleanBuffer::from_iter(iter).into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;