diff --git a/rust/arrow/examples/tensor_builder.rs b/rust/arrow/examples/tensor_builder.rs
index 19421715ceb..1ef53920e04 100644
--- a/rust/arrow/examples/tensor_builder.rs
+++ b/rust/arrow/examples/tensor_builder.rs
@@ -18,7 +18,7 @@
 ///! Tensor builder example
 extern crate arrow;
 
-use arrow::array::*; //{BufferBuilderTrait, Int32BufferBuilder, Float32BufferBuilder};
+use arrow::array::*; //{Int32BufferBuilder, Float32BufferBuilder};
 use arrow::buffer::Buffer;
 use arrow::datatypes::ToByteSlice;
 use arrow::error::Result;
@@ -30,7 +30,7 @@ fn main() -> Result<()> {
     // to match the required size for each buffer
     let mut builder = Int32BufferBuilder::new(16);
     for i in 0..16 {
-        builder.append(i).unwrap();
+        builder.append(i);
     }
     let buf = builder.finish();
 
@@ -43,10 +43,10 @@ fn main() -> Result<()> {
 
     // Creating a tensor using float type buffer builder
     let mut builder = Float32BufferBuilder::new(4);
-    builder.append(1.0).unwrap();
-    builder.append(2.0).unwrap();
-    builder.append(3.0).unwrap();
-    builder.append(4.0).unwrap();
+    builder.append(1.0);
+    builder.append(2.0);
+    builder.append(3.0);
+    builder.append(4.0);
     let buf = builder.finish();
 
     // When building the tensor the buffer and shape are necessary
diff --git a/rust/arrow/src/array/builder.rs b/rust/arrow/src/array/builder.rs
index 3526c03c50c..3dff38be846 100644
--- a/rust/arrow/src/array/builder.rs
+++ b/rust/arrow/src/array/builder.rs
@@ -36,7 +36,7 @@ use crate::util::bit_util;
 ///  Converts a `MutableBuffer` to a `BufferBuilder<T>`.
 ///
 /// `slots` is the number of array slots currently represented in the `MutableBuffer`.
-pub(crate) fn mutable_buffer_to_builder<T: ArrowPrimitiveType>(
+pub(crate) fn mutable_buffer_to_builder<T: ArrowNativeType>(
     mutable_buffer: MutableBuffer,
     slots: usize,
 ) -> BufferBuilder<T> {
@@ -50,7 +50,7 @@ pub(crate) fn mutable_buffer_to_builder<T: ArrowPrimitiveType>(
 ///  Converts a `BufferBuilder<T>` into it's underlying `MutableBuffer`.
 ///
 /// `From` is not implemented because associated type bounds are unstable.
-pub(crate) fn builder_to_mutable_buffer<T: ArrowPrimitiveType>(
+pub(crate) fn builder_to_mutable_buffer<T: ArrowNativeType>(
     builder: BufferBuilder<T>,
 ) -> MutableBuffer {
     builder.buffer
@@ -58,12 +58,6 @@ pub(crate) fn builder_to_mutable_buffer<T: ArrowPrimitiveType>(
 
 /// Builder for creating a [`Buffer`](crate::buffer::Buffer) object.
 ///
-/// This builder is implemented for primitive types and creates a
-/// buffer with a zero-copy `build()` method.
-///
-/// See trait [`BufferBuilderTrait`](crate::array::BufferBuilderTrait)
-/// for further documentation and examples.
-///
 /// A [`Buffer`](crate::buffer::Buffer) is the underlying data
 /// structure of Arrow's [`Arrays`](crate::array::Array).
 ///
@@ -73,7 +67,7 @@ pub(crate) fn builder_to_mutable_buffer<T: ArrowPrimitiveType>(
 /// # Example:
 ///
 /// ```
-/// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+/// use arrow::array::UInt8BufferBuilder;
 ///
 /// # fn main() -> arrow::error::Result<()> {
 /// let mut builder = UInt8BufferBuilder::new(100);
@@ -86,109 +80,128 @@ pub(crate) fn builder_to_mutable_buffer<T: ArrowPrimitiveType>(
 /// # }
 /// ```
 #[derive(Debug)]
-pub struct BufferBuilder<T: ArrowPrimitiveType> {
+pub struct BufferBuilder<T: ArrowNativeType> {
     buffer: MutableBuffer,
     len: usize,
     _marker: PhantomData<T>,
 }
 
-/// Trait for simplifying the construction of [`Buffers`](crate::buffer::Buffer).
-///
-/// This trait is used mainly to offer separate implementations for
-/// numeric types and boolean types, while still be able to call methods on buffer builder
-/// with generic primitive type.
-/// Separate implementations of this trait allow to add implementation-details,
-/// e.g. the implementation for boolean types uses bit-packing.
-pub trait BufferBuilderTrait<T: ArrowPrimitiveType> {
+impl<T: ArrowNativeType> BufferBuilder<T> {
     /// Creates a new builder with initial capacity for _at least_ `capacity`
     /// elements of type `T`.
     ///
     /// The capacity can later be manually adjusted with the
-    /// [`reserve()`](BufferBuilderTrait::reserve) method.
+    /// [`reserve()`](BufferBuilder::reserve) method.
     /// Also the
-    /// [`append()`](BufferBuilderTrait::append),
-    /// [`append_slice()`](BufferBuilderTrait::append_slice) and
-    /// [`advance()`](BufferBuilderTrait::advance)
+    /// [`append()`](BufferBuilder::append),
+    /// [`append_slice()`](BufferBuilder::append_slice) and
+    /// [`advance()`](BufferBuilder::advance)
     /// methods automatically increase the capacity if needed.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     ///
     /// assert!(builder.capacity() >= 10);
     /// ```
-    fn new(capacity: usize) -> Self;
+    #[inline]
+    pub fn new(capacity: usize) -> Self {
+        let buffer = MutableBuffer::new(capacity * mem::size_of::<T>());
+
+        Self {
+            buffer,
+            len: 0,
+            _marker: PhantomData,
+        }
+    }
 
     /// Returns the current number of array elements in the internal buffer.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.len(), 1);
     /// ```
-    fn len(&self) -> usize;
+    pub fn len(&self) -> usize {
+        self.len
+    }
 
     /// Returns whether the internal buffer is empty.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.is_empty(), false);
     /// ```
-    fn is_empty(&self) -> bool;
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
 
     /// Returns the actual capacity (number of elements) of the internal buffer.
     ///
     /// Note: the internal capacity returned by this method might be larger than
     /// what you'd expect after setting the capacity in the `new()` or `reserve()`
     /// functions.
-    fn capacity(&self) -> usize;
+    pub fn capacity(&self) -> usize {
+        let byte_capacity = self.buffer.capacity();
+        byte_capacity / std::mem::size_of::<T>()
+    }
 
     /// Increases the number of elements in the internal buffer by `n`
     /// and resizes the buffer as needed.
     ///
-    /// The values of the newly added elements are undefined.
+    /// The values of the newly added elements are 0.
     /// This method is usually used when appending `NULL` values to the buffer
     /// as they still require physical memory space.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.advance(2);
     ///
     /// assert_eq!(builder.len(), 2);
     /// ```
-    fn advance(&mut self, n: usize) -> Result<()>;
+    #[inline]
+    pub fn advance(&mut self, i: usize) {
+        let new_buffer_len = (self.len + i) * mem::size_of::<T>();
+        self.buffer.resize(new_buffer_len);
+        self.len += i;
+    }
 
     /// Reserves memory for _at least_ `n` more elements of type `T`.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.reserve(10);
     ///
     /// assert!(builder.capacity() >= 20);
     /// ```
-    fn reserve(&mut self, n: usize);
+    #[inline]
+    pub fn reserve(&mut self, n: usize) {
+        let new_capacity = self.len + n;
+        let byte_capacity = mem::size_of::<T>() * new_capacity;
+        self.buffer.reserve(byte_capacity);
+    }
 
     /// Appends a value of type `T` into the builder,
     /// growing the internal buffer as needed.
@@ -196,14 +209,23 @@ pub trait BufferBuilderTrait<T: ArrowPrimitiveType> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.len(), 1);
     /// ```
-    fn append(&mut self, value: T::Native) -> Result<()>;
+    #[inline]
+    pub fn append(&mut self, v: T) {
+        self.reserve(1);
+        self.write_bytes(v.to_byte_slice(), 1);
+    }
+
+    fn write_bytes(&mut self, bytes: &[u8], len_added: usize) {
+        self.buffer.extend_from_slice(bytes);
+        self.len += len_added;
+    }
 
     /// Appends a value of type `T` into the builder N times,
     /// growing the internal buffer as needed.
@@ -211,35 +233,47 @@ pub trait BufferBuilderTrait<T: ArrowPrimitiveType> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append_n(10, 42);
     ///
     /// assert_eq!(builder.len(), 10);
     /// ```
-    fn append_n(&mut self, n: usize, value: T::Native) -> Result<()>;
+    #[inline]
+    pub fn append_n(&mut self, n: usize, v: T) {
+        self.reserve(n);
+        for _ in 0..n {
+            self.write_bytes(v.to_byte_slice(), 1);
+        }
+    }
 
     /// Appends a slice of type `T`, growing the internal buffer as needed.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append_slice(&[42, 44, 46]);
     ///
     /// assert_eq!(builder.len(), 3);
     /// ```
-    fn append_slice(&mut self, slice: &[T::Native]) -> Result<()>;
+    #[inline]
+    pub fn append_slice(&mut self, slice: &[T]) {
+        let array_slots = slice.len();
+        self.reserve(array_slots);
+
+        self.write_bytes(slice.to_byte_slice(), array_slots);
+    }
 
     /// Resets this builder and returns an immutable [`Buffer`](crate::buffer::Buffer).
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{UInt8BufferBuilder, BufferBuilderTrait};
+    /// use arrow::array::UInt8BufferBuilder;
     ///
     /// let mut builder = UInt8BufferBuilder::new(10);
     /// builder.append_slice(&[42, 44, 46]);
@@ -248,76 +282,8 @@ pub trait BufferBuilderTrait<T: ArrowPrimitiveType> {
     ///
     /// assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 44, 46]);
     /// ```
-    fn finish(&mut self) -> Buffer;
-}
-
-impl<T: ArrowPrimitiveType> BufferBuilderTrait<T> for BufferBuilder<T> {
     #[inline]
-    fn new(capacity: usize) -> Self {
-        let buffer = MutableBuffer::new(capacity * mem::size_of::<T::Native>());
-
-        Self {
-            buffer,
-            len: 0,
-            _marker: PhantomData,
-        }
-    }
-
-    fn len(&self) -> usize {
-        self.len
-    }
-
-    fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    fn capacity(&self) -> usize {
-        let byte_capacity = self.buffer.capacity();
-        byte_capacity / T::get_byte_width()
-    }
-
-    #[inline]
-    fn advance(&mut self, i: usize) -> Result<()> {
-        let new_buffer_len = (self.len + i) * mem::size_of::<T::Native>();
-        self.buffer.resize(new_buffer_len);
-        self.len += i;
-        Ok(())
-    }
-
-    #[inline]
-    fn reserve(&mut self, n: usize) {
-        let new_capacity = self.len + n;
-        let byte_capacity = mem::size_of::<T::Native>() * new_capacity;
-        self.buffer.reserve(byte_capacity);
-    }
-
-    #[inline]
-    fn append(&mut self, v: T::Native) -> Result<()> {
-        self.reserve(1);
-        self.write_bytes(v.to_byte_slice(), 1);
-        Ok(())
-    }
-
-    #[inline]
-    fn append_n(&mut self, n: usize, v: T::Native) -> Result<()> {
-        self.reserve(n);
-        for _ in 0..n {
-            self.write_bytes(v.to_byte_slice(), 1);
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn append_slice(&mut self, slice: &[T::Native]) -> Result<()> {
-        let array_slots = slice.len();
-        self.reserve(array_slots);
-
-        self.write_bytes(slice.to_byte_slice(), array_slots);
-        Ok(())
-    }
-
-    #[inline]
-    fn finish(&mut self) -> Buffer {
+    pub fn finish(&mut self) -> Buffer {
         let buf = std::mem::replace(&mut self.buffer, MutableBuffer::new(0));
         self.len = 0;
         buf.freeze()
@@ -354,11 +320,10 @@ impl BooleanBufferBuilder {
     }
 
     #[inline]
-    pub fn advance(&mut self, i: usize) -> Result<()> {
+    pub fn advance(&mut self, i: usize) {
         let new_buffer_len = bit_util::ceil(self.len + i, 8);
         self.buffer.resize(new_buffer_len);
         self.len += i;
-        Ok(())
     }
 
     #[inline]
@@ -374,7 +339,7 @@ impl BooleanBufferBuilder {
     }
 
     #[inline]
-    pub fn append(&mut self, v: bool) -> Result<()> {
+    pub fn append(&mut self, v: bool) {
         self.reserve(1);
         if v {
             let data = unsafe {
@@ -386,11 +351,10 @@ impl BooleanBufferBuilder {
             bit_util::set_bit(data, self.len);
         }
         self.len += 1;
-        Ok(())
     }
 
     #[inline]
-    pub fn append_n(&mut self, n: usize, v: bool) -> Result<()> {
+    pub fn append_n(&mut self, n: usize, v: bool) {
         self.reserve(n);
         if n != 0 && v {
             let data = unsafe {
@@ -402,11 +366,10 @@ impl BooleanBufferBuilder {
             (self.len..self.len + n).for_each(|i| bit_util::set_bit(data, i))
         }
         self.len += n;
-        Ok(())
     }
 
     #[inline]
-    pub fn append_slice(&mut self, slice: &[bool]) -> Result<()> {
+    pub fn append_slice(&mut self, slice: &[bool]) {
         let array_slots = slice.len();
         self.reserve(array_slots);
 
@@ -421,7 +384,6 @@ impl BooleanBufferBuilder {
             }
             self.len += 1;
         }
-        Ok(())
     }
 
     #[inline]
@@ -436,16 +398,6 @@ impl BooleanBufferBuilder {
     }
 }
 
-impl<T: ArrowPrimitiveType> BufferBuilder<T> {
-    /// Writes a byte slice to the underlying buffer and updates the `len`, i.e. the
-    /// number array elements in the builder.  Also, converts the `io::Result`
-    /// required by the `Write` trait to the Arrow `Result` type.
-    fn write_bytes(&mut self, bytes: &[u8], len_added: usize) {
-        self.buffer.extend_from_slice(bytes);
-        self.len += len_added;
-    }
-}
-
 /// Trait for dealing with different array builders at runtime
 pub trait ArrayBuilder: Any {
     /// Returns the number of array slots in the builder
@@ -498,15 +450,15 @@ impl BooleanBuilder {
 
     /// Appends a value of type `T` into the builder
     pub fn append_value(&mut self, v: bool) -> Result<()> {
-        self.bitmap_builder.append(true)?;
-        self.values_builder.append(v)?;
+        self.bitmap_builder.append(true);
+        self.values_builder.append(v);
         Ok(())
     }
 
     /// Appends a null slot into the builder
     pub fn append_null(&mut self) -> Result<()> {
-        self.bitmap_builder.append(false)?;
-        self.values_builder.advance(1)?;
+        self.bitmap_builder.append(false);
+        self.values_builder.advance(1);
         Ok(())
     }
 
@@ -521,8 +473,8 @@ impl BooleanBuilder {
 
     /// Appends a slice of type `T` into the builder
     pub fn append_slice(&mut self, v: &[bool]) -> Result<()> {
-        self.bitmap_builder.append_n(v.len(), true)?;
-        self.values_builder.append_slice(v)?;
+        self.bitmap_builder.append_n(v.len(), true);
+        self.values_builder.append_slice(v);
         Ok(())
     }
 
@@ -533,8 +485,9 @@ impl BooleanBuilder {
                 "Value and validity lengths must be equal".to_string(),
             ));
         }
-        self.bitmap_builder.append_slice(is_valid)?;
-        self.values_builder.append_slice(values)
+        self.bitmap_builder.append_slice(is_valid);
+        self.values_builder.append_slice(values);
+        Ok(())
     }
 
     /// Builds the [BooleanArray] and reset this builder.
@@ -590,7 +543,7 @@ impl ArrayBuilder for BooleanBuilder {
 ///  Array builder for fixed-width primitive types
 #[derive(Debug)]
 pub struct PrimitiveBuilder<T: ArrowPrimitiveType> {
-    values_builder: BufferBuilder<T>,
+    values_builder: BufferBuilder<T::Native>,
     bitmap_builder: BooleanBufferBuilder,
 }
 
@@ -630,7 +583,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Creates a new primitive array builder
     pub fn new(capacity: usize) -> Self {
         Self {
-            values_builder: BufferBuilder::<T>::new(capacity),
+            values_builder: BufferBuilder::<T::Native>::new(capacity),
             bitmap_builder: BooleanBufferBuilder::new(capacity),
         }
     }
@@ -642,15 +595,15 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
 
     /// Appends a value of type `T` into the builder
     pub fn append_value(&mut self, v: T::Native) -> Result<()> {
-        self.bitmap_builder.append(true)?;
-        self.values_builder.append(v)?;
+        self.bitmap_builder.append(true);
+        self.values_builder.append(v);
         Ok(())
     }
 
     /// Appends a null slot into the builder
     pub fn append_null(&mut self) -> Result<()> {
-        self.bitmap_builder.append(false)?;
-        self.values_builder.advance(1)?;
+        self.bitmap_builder.append(false);
+        self.values_builder.advance(1);
         Ok(())
     }
 
@@ -665,8 +618,8 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
 
     /// Appends a slice of type `T` into the builder
     pub fn append_slice(&mut self, v: &[T::Native]) -> Result<()> {
-        self.bitmap_builder.append_n(v.len(), true)?;
-        self.values_builder.append_slice(v)?;
+        self.bitmap_builder.append_n(v.len(), true);
+        self.values_builder.append_slice(v);
         Ok(())
     }
 
@@ -681,8 +634,9 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
                 "Value and validity lengths must be equal".to_string(),
             ));
         }
-        self.bitmap_builder.append_slice(is_valid)?;
-        self.values_builder.append_slice(values)
+        self.bitmap_builder.append_slice(is_valid);
+        self.values_builder.append_slice(values);
+        Ok(())
     }
 
     /// Builds the `PrimitiveArray` and reset this builder.
@@ -727,7 +681,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
 ///  Array builder for `ListArray`
 #[derive(Debug)]
 pub struct ListBuilder<T: ArrayBuilder> {
-    offsets_builder: Int32BufferBuilder,
+    offsets_builder: BufferBuilder<i32>,
     bitmap_builder: BooleanBufferBuilder,
     values_builder: T,
     len: usize,
@@ -744,7 +698,7 @@ impl<T: ArrayBuilder> ListBuilder<T> {
     /// `capacity` is the number of items to pre-allocate space for in this builder
     pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
         let mut offsets_builder = Int32BufferBuilder::new(capacity + 1);
-        offsets_builder.append(0).unwrap();
+        offsets_builder.append(0);
         Self {
             offsets_builder,
             bitmap_builder: BooleanBufferBuilder::new(capacity),
@@ -804,8 +758,8 @@ where
     /// Finish the current variable-length list array slot
     pub fn append(&mut self, is_valid: bool) -> Result<()> {
         self.offsets_builder
-            .append(self.values_builder.len() as i32)?;
-        self.bitmap_builder.append(is_valid)?;
+            .append(self.values_builder.len() as i32);
+        self.bitmap_builder.append(is_valid);
         self.len += 1;
         Ok(())
     }
@@ -825,7 +779,7 @@ where
         let offset_buffer = self.offsets_builder.finish();
         let null_bit_buffer = self.bitmap_builder.finish();
         let nulls = null_bit_buffer.count_set_bits();
-        self.offsets_builder.append(0).unwrap();
+        self.offsets_builder.append(0);
         let data = ArrayData::builder(DataType::List(Box::new(Field::new(
             "item",
             values_data.data_type().clone(),
@@ -845,7 +799,7 @@ where
 ///  Array builder for `ListArray`
 #[derive(Debug)]
 pub struct LargeListBuilder<T: ArrayBuilder> {
-    offsets_builder: Int64BufferBuilder,
+    offsets_builder: BufferBuilder<i64>,
     bitmap_builder: BooleanBufferBuilder,
     values_builder: T,
     len: usize,
@@ -862,7 +816,7 @@ impl<T: ArrayBuilder> LargeListBuilder<T> {
     /// `capacity` is the number of items to pre-allocate space for in this builder
     pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
         let mut offsets_builder = Int64BufferBuilder::new(capacity + 1);
-        offsets_builder.append(0).unwrap();
+        offsets_builder.append(0);
         Self {
             offsets_builder,
             bitmap_builder: BooleanBufferBuilder::new(capacity),
@@ -922,8 +876,8 @@ where
     /// Finish the current variable-length list array slot
     pub fn append(&mut self, is_valid: bool) -> Result<()> {
         self.offsets_builder
-            .append(self.values_builder.len() as i64)?;
-        self.bitmap_builder.append(is_valid)?;
+            .append(self.values_builder.len() as i64);
+        self.bitmap_builder.append(is_valid);
         self.len += 1;
         Ok(())
     }
@@ -943,7 +897,7 @@ where
         let offset_buffer = self.offsets_builder.finish();
         let null_bit_buffer = self.bitmap_builder.finish();
         let nulls = null_bit_buffer.count_set_bits();
-        self.offsets_builder.append(0).unwrap();
+        self.offsets_builder.append(0);
         let data = ArrayData::builder(DataType::LargeList(Box::new(Field::new(
             "item",
             values_data.data_type().clone(),
@@ -982,7 +936,7 @@ impl<T: ArrayBuilder> FixedSizeListBuilder<T> {
     /// `capacity` is the number of items to pre-allocate space for in this builder
     pub fn with_capacity(values_builder: T, length: i32, capacity: usize) -> Self {
         let mut offsets_builder = Int32BufferBuilder::new(capacity + 1);
-        offsets_builder.append(0).unwrap();
+        offsets_builder.append(0);
         Self {
             bitmap_builder: BooleanBufferBuilder::new(capacity),
             values_builder,
@@ -1045,7 +999,7 @@ where
 
     /// Finish the current variable-length list array slot
     pub fn append(&mut self, is_valid: bool) -> Result<()> {
-        self.bitmap_builder.append(is_valid)?;
+        self.bitmap_builder.append(is_valid);
         self.len += 1;
         Ok(())
     }
@@ -1785,7 +1739,7 @@ impl StructBuilder {
     /// Appends an element (either null or non-null) to the struct. The actual elements
     /// should be appended for each child sub-array in a consistent way.
     pub fn append(&mut self, is_valid: bool) -> Result<()> {
-        self.bitmap_builder.append(is_valid)?;
+        self.bitmap_builder.append(is_valid);
         self.len += 1;
         Ok(())
     }
@@ -1871,15 +1825,15 @@ impl FieldData {
             .values_buffer
             .take()
             .expect("Values buffer was never created");
-        let mut builder: BufferBuilder<T> =
+        let mut builder: BufferBuilder<T::Native> =
             mutable_buffer_to_builder(values_buffer, self.slots);
-        builder.append(v)?;
+        builder.append(v);
         let mutable_buffer = builder_to_mutable_buffer(builder);
         self.values_buffer = Some(mutable_buffer);
 
         self.slots += 1;
         if let Some(b) = &mut self.bitmap_builder {
-            b.append(true)?
+            b.append(true)
         };
         Ok(())
     }
@@ -1891,14 +1845,14 @@ impl FieldData {
                 .values_buffer
                 .take()
                 .expect("Values buffer was never created");
-            let mut builder: BufferBuilder<T> =
+            let mut builder: BufferBuilder<T::Native> =
                 mutable_buffer_to_builder(values_buffer, self.slots);
-            builder.advance(1)?;
+            builder.advance(1);
             let mutable_buffer = builder_to_mutable_buffer(builder);
             self.values_buffer = Some(mutable_buffer);
             self.slots += 1;
             self.null_count += 1;
-            b.append(false)?;
+            b.append(false);
         };
         Ok(())
     }
@@ -1984,16 +1938,16 @@ impl UnionBuilder {
         if self.bitmap_builder.is_none() {
             let mut builder = BooleanBufferBuilder::new(self.len + 1);
             for _ in 0..self.len {
-                builder.append(true)?;
+                builder.append(true);
             }
             self.bitmap_builder = Some(builder)
         }
         self.bitmap_builder
             .as_mut()
             .expect("Cannot be None")
-            .append(false)?;
+            .append(false);
 
-        self.type_id_builder.append(i8::default())?;
+        self.type_id_builder.append(i8::default());
 
         // Handle sparse union
         if self.value_offset_builder.is_none() {
@@ -2030,12 +1984,12 @@ impl UnionBuilder {
                 }
             },
         };
-        self.type_id_builder.append(field_data.type_id)?;
+        self.type_id_builder.append(field_data.type_id);
 
         match &mut self.value_offset_builder {
             // Dense Union
             Some(offset_builder) => {
-                offset_builder.append(field_data.slots as i32)?;
+                offset_builder.append(field_data.slots as i32);
             }
             // Sparse Union
             None => {
@@ -2051,7 +2005,7 @@ impl UnionBuilder {
 
         // Update the bitmap builder if it exists
         if let Some(b) = &mut self.bitmap_builder {
-            b.append(true)?;
+            b.append(true);
         }
         self.len += 1;
         Ok(())
@@ -2373,7 +2327,7 @@ mod tests {
     #[test]
     fn test_builder_i32_alloc_zero_bytes() {
         let mut b = Int32BufferBuilder::new(0);
-        b.append(123).unwrap();
+        b.append(123);
         let a = b.finish();
         assert_eq!(4, a.len());
     }
@@ -2382,7 +2336,7 @@ mod tests {
     fn test_builder_i32() {
         let mut b = Int32BufferBuilder::new(5);
         for i in 0..5 {
-            b.append(i).unwrap();
+            b.append(i);
         }
         assert_eq!(16, b.capacity());
         let a = b.finish();
@@ -2394,7 +2348,7 @@ mod tests {
         let mut b = Int32BufferBuilder::new(2);
         assert_eq!(16, b.capacity());
         for i in 0..20 {
-            b.append(i).unwrap();
+            b.append(i);
         }
         assert_eq!(32, b.capacity());
         let a = b.finish();
@@ -2406,7 +2360,7 @@ mod tests {
         let mut b = Int32BufferBuilder::new(5);
         assert_eq!(16, b.capacity());
         for i in 0..10 {
-            b.append(i).unwrap();
+            b.append(i);
         }
         let mut a = b.finish();
         assert_eq!(40, a.len());
@@ -2415,7 +2369,7 @@ mod tests {
 
         // Try build another buffer after cleaning up.
         for i in 0..20 {
-            b.append(i).unwrap()
+            b.append(i)
         }
         assert_eq!(32, b.capacity());
         a = b.finish();
@@ -2442,13 +2396,13 @@ mod tests {
     #[test]
     fn test_append_slice() {
         let mut b = UInt8BufferBuilder::new(0);
-        b.append_slice(b"Hello, ").unwrap();
-        b.append_slice(b"World!").unwrap();
+        b.append_slice(b"Hello, ");
+        b.append_slice(b"World!");
         let buffer = b.finish();
         assert_eq!(13, buffer.len());
 
         let mut b = Int32BufferBuilder::new(0);
-        b.append_slice(&[32, 54]).unwrap();
+        b.append_slice(&[32, 54]);
         let buffer = b.finish();
         assert_eq!(8, buffer.len());
     }
@@ -2482,17 +2436,17 @@ mod tests {
     #[test]
     fn test_write_bytes() {
         let mut b = BooleanBufferBuilder::new(4);
-        b.append(false).unwrap();
-        b.append(true).unwrap();
-        b.append(false).unwrap();
-        b.append(true).unwrap();
+        b.append(false);
+        b.append(true);
+        b.append(false);
+        b.append(true);
         assert_eq!(4, b.len());
         assert_eq!(512, b.capacity());
         let buffer = b.finish();
         assert_eq!(1, buffer.len());
 
         let mut b = BooleanBufferBuilder::new(4);
-        b.append_slice(&[false, true, false, true]).unwrap();
+        b.append_slice(&[false, true, false, true]);
         assert_eq!(4, b.len());
         assert_eq!(512, b.capacity());
         let buffer = b.finish();
@@ -2542,9 +2496,9 @@ mod tests {
 
         for i in 0..10 {
             if i == 3 || i == 6 || i == 9 {
-                builder.append(true).unwrap();
+                builder.append(true);
             } else {
-                builder.append(false).unwrap();
+                builder.append(false);
             }
         }
         let buf2 = builder.finish();
diff --git a/rust/arrow/src/array/mod.rs b/rust/arrow/src/array/mod.rs
index 4cd83e309c0..298fc632997 100644
--- a/rust/arrow/src/array/mod.rs
+++ b/rust/arrow/src/array/mod.rs
@@ -179,18 +179,17 @@ pub use self::array_string::StringOffsetSizeTrait;
 
 pub use self::builder::BooleanBufferBuilder;
 pub use self::builder::BufferBuilder;
-pub use self::builder::BufferBuilderTrait;
 
-pub type Int8BufferBuilder = BufferBuilder<Int8Type>;
-pub type Int16BufferBuilder = BufferBuilder<Int16Type>;
-pub type Int32BufferBuilder = BufferBuilder<Int32Type>;
-pub type Int64BufferBuilder = BufferBuilder<Int64Type>;
-pub type UInt8BufferBuilder = BufferBuilder<UInt8Type>;
-pub type UInt16BufferBuilder = BufferBuilder<UInt16Type>;
-pub type UInt32BufferBuilder = BufferBuilder<UInt32Type>;
-pub type UInt64BufferBuilder = BufferBuilder<UInt64Type>;
-pub type Float32BufferBuilder = BufferBuilder<Float32Type>;
-pub type Float64BufferBuilder = BufferBuilder<Float64Type>;
+pub type Int8BufferBuilder = BufferBuilder<i8>;
+pub type Int16BufferBuilder = BufferBuilder<i16>;
+pub type Int32BufferBuilder = BufferBuilder<i32>;
+pub type Int64BufferBuilder = BufferBuilder<i64>;
+pub type UInt8BufferBuilder = BufferBuilder<u8>;
+pub type UInt16BufferBuilder = BufferBuilder<u16>;
+pub type UInt32BufferBuilder = BufferBuilder<u32>;
+pub type UInt64BufferBuilder = BufferBuilder<u64>;
+pub type Float32BufferBuilder = BufferBuilder<f32>;
+pub type Float64BufferBuilder = BufferBuilder<f64>;
 
 pub type TimestampSecondBufferBuilder = BufferBuilder<TimestampSecondType>;
 pub type TimestampMillisecondBufferBuilder = BufferBuilder<TimestampMillisecondType>;
diff --git a/rust/arrow/src/compute/kernels/comparison.rs b/rust/arrow/src/compute/kernels/comparison.rs
index 35f93304371..f77ce57f76c 100644
--- a/rust/arrow/src/compute/kernels/comparison.rs
+++ b/rust/arrow/src/compute/kernels/comparison.rs
@@ -163,7 +163,7 @@ pub fn like_utf8(left: &StringArray, right: &StringArray) -> Result<BooleanArray
             map.get(pat).unwrap()
         };
 
-        result.append(re.is_match(haystack))?;
+        result.append(re.is_match(haystack));
     }
 
     let data = ArrayData::new(
@@ -189,18 +189,18 @@ pub fn like_utf8_scalar(left: &StringArray, right: &str) -> Result<BooleanArray>
     if !right.contains(is_like_pattern) {
         // fast path, can use equals
         for i in 0..left.len() {
-            result.append(left.value(i) == right)?;
+            result.append(left.value(i) == right);
         }
     } else if right.ends_with('%') && !right[..right.len() - 1].contains(is_like_pattern)
     {
         // fast path, can use starts_with
         for i in 0..left.len() {
-            result.append(left.value(i).starts_with(&right[..right.len() - 1]))?;
+            result.append(left.value(i).starts_with(&right[..right.len() - 1]));
         }
     } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
         // fast path, can use ends_with
         for i in 0..left.len() {
-            result.append(left.value(i).ends_with(&right[1..]))?;
+            result.append(left.value(i).ends_with(&right[1..]));
         }
     } else {
         let re_pattern = right.replace("%", ".*").replace("_", ".");
@@ -213,7 +213,7 @@ pub fn like_utf8_scalar(left: &StringArray, right: &str) -> Result<BooleanArray>
 
         for i in 0..left.len() {
             let haystack = left.value(i);
-            result.append(re.is_match(haystack))?;
+            result.append(re.is_match(haystack));
         }
     };
 
@@ -259,7 +259,7 @@ pub fn nlike_utf8(left: &StringArray, right: &StringArray) -> Result<BooleanArra
             map.get(pat).unwrap()
         };
 
-        result.append(!re.is_match(haystack))?;
+        result.append(!re.is_match(haystack));
     }
 
     let data = ArrayData::new(
@@ -281,18 +281,18 @@ pub fn nlike_utf8_scalar(left: &StringArray, right: &str) -> Result<BooleanArray
     if !right.contains(is_like_pattern) {
         // fast path, can use equals
         for i in 0..left.len() {
-            result.append(left.value(i) != right)?;
+            result.append(left.value(i) != right);
         }
     } else if right.ends_with('%') && !right[..right.len() - 1].contains(is_like_pattern)
     {
         // fast path, can use ends_with
         for i in 0..left.len() {
-            result.append(!left.value(i).starts_with(&right[..right.len() - 1]))?;
+            result.append(!left.value(i).starts_with(&right[..right.len() - 1]));
         }
     } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
         // fast path, can use starts_with
         for i in 0..left.len() {
-            result.append(!left.value(i).ends_with(&right[1..]))?;
+            result.append(!left.value(i).ends_with(&right[1..]));
         }
     } else {
         let re_pattern = right.replace("%", ".*").replace("_", ".");
@@ -304,7 +304,7 @@ pub fn nlike_utf8_scalar(left: &StringArray, right: &str) -> Result<BooleanArray
         })?;
         for i in 0..left.len() {
             let haystack = left.value(i);
-            result.append(!re.is_match(haystack))?;
+            result.append(!re.is_match(haystack));
         }
     }
 
diff --git a/rust/arrow/src/tensor.rs b/rust/arrow/src/tensor.rs
index 92c5cfee7b1..35e45a25c38 100644
--- a/rust/arrow/src/tensor.rs
+++ b/rust/arrow/src/tensor.rs
@@ -359,7 +359,7 @@ mod tests {
     fn test_tensor() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
         let tensor = Int32Tensor::try_new(buf, Some(vec![2, 8]), None, None).unwrap();
@@ -374,7 +374,7 @@ mod tests {
     fn test_new_row_major() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
         let tensor = Int32Tensor::new_row_major(buf, Some(vec![2, 8]), None).unwrap();
@@ -392,7 +392,7 @@ mod tests {
     fn test_new_column_major() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
         let tensor = Int32Tensor::new_column_major(buf, Some(vec![2, 8]), None).unwrap();
@@ -410,7 +410,7 @@ mod tests {
     fn test_with_names() {
         let mut builder = Int64BufferBuilder::new(8);
         for i in 0..8 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
         let names = vec!["Dim 1", "Dim 2"];
@@ -431,7 +431,7 @@ mod tests {
     fn test_inconsistent_strides() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
 
@@ -447,7 +447,7 @@ mod tests {
     fn test_inconsistent_names() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
 
@@ -467,7 +467,7 @@ mod tests {
     fn test_incorrect_shape() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
 
@@ -482,7 +482,7 @@ mod tests {
     fn test_incorrect_stride() {
         let mut builder = Int32BufferBuilder::new(16);
         for i in 0..16 {
-            builder.append(i).unwrap();
+            builder.append(i);
         }
         let buf = builder.finish();
 
diff --git a/rust/parquet/src/arrow/array_reader.rs b/rust/parquet/src/arrow/array_reader.rs
index f4d2a79fd8d..eb9548a8622 100644
--- a/rust/parquet/src/arrow/array_reader.rs
+++ b/rust/parquet/src/arrow/array_reader.rs
@@ -25,10 +25,10 @@ use std::vec::Vec;
 
 use arrow::array::{
     Array, ArrayData, ArrayDataBuilder, ArrayDataRef, ArrayRef, BinaryArray,
-    BinaryBuilder, BooleanArray, BooleanBufferBuilder, BufferBuilderTrait,
-    FixedSizeBinaryArray, FixedSizeBinaryBuilder, GenericListArray, Int16BufferBuilder,
-    ListBuilder, OffsetSizeTrait, PrimitiveArray, PrimitiveBuilder, StringArray,
-    StringBuilder, StructArray,
+    BinaryBuilder, BooleanArray, BooleanBufferBuilder, FixedSizeBinaryArray,
+    FixedSizeBinaryBuilder, GenericListArray, Int16BufferBuilder, ListBuilder,
+    OffsetSizeTrait, PrimitiveArray, PrimitiveBuilder, StringArray, StringBuilder,
+    StructArray,
 };
 use arrow::buffer::{Buffer, MutableBuffer};
 use arrow::datatypes::{
@@ -292,7 +292,7 @@ impl<T: DataType> ArrayReader for PrimitiveArrayReader<T> {
             let mut boolean_buffer = BooleanBufferBuilder::new(record_data.len());
 
             for e in record_data.data() {
-                boolean_buffer.append(*e > 0)?;
+                boolean_buffer.append(*e > 0);
             }
             record_data = boolean_buffer.finish();
         }
@@ -1082,7 +1082,7 @@ impl ArrayReader for StructArrayReader {
             if !not_null {
                 null_count += 1;
             }
-            bitmap_builder.append(not_null)?;
+            bitmap_builder.append(not_null);
         }
 
         // Now we can build array data
@@ -1110,7 +1110,7 @@ impl ArrayReader for StructArrayReader {
             .get_rep_levels()
             .map(|data| -> Result<Buffer> {
                 let mut buffer = Int16BufferBuilder::new(children_array_len);
-                buffer.append_slice(data)?;
+                buffer.append_slice(data);
                 Ok(buffer.finish())
             })
             .transpose()?;
diff --git a/rust/parquet/src/arrow/record_reader.rs b/rust/parquet/src/arrow/record_reader.rs
index 14908de6d43..0a7c17fdcfb 100644
--- a/rust/parquet/src/arrow/record_reader.rs
+++ b/rust/parquet/src/arrow/record_reader.rs
@@ -249,7 +249,7 @@ impl<T: DataType> RecordReader<T> {
                 self.null_bitmap
                     .as_mut()
                     .unwrap()
-                    .append(old_bitmap.is_set(i))?;
+                    .append(old_bitmap.is_set(i));
             }
 
             Ok(Some(old_bitmap.into_buffer()))
@@ -357,9 +357,8 @@ impl<T: DataType> RecordReader<T> {
                     "Definition levels should exist when data is less than levels!"
                 )
             })?;
-            (0..levels_read).try_for_each(|idx| {
-                null_buffer.append(def_levels[idx] == max_def_level)
-            })?;
+            (0..levels_read)
+                .for_each(|idx| null_buffer.append(def_levels[idx] == max_def_level));
         }
 
         let values_read = max(values_read, levels_read);
@@ -439,9 +438,7 @@ mod tests {
     use crate::schema::parser::parse_message_type;
     use crate::schema::types::SchemaDescriptor;
     use crate::util::test_common::page_util::{DataPageBuilder, DataPageBuilderImpl};
-    use arrow::array::{
-        BooleanBufferBuilder, BufferBuilderTrait, Int16BufferBuilder, Int32BufferBuilder,
-    };
+    use arrow::array::{BooleanBufferBuilder, Int16BufferBuilder, Int32BufferBuilder};
     use arrow::bitmap::Bitmap;
     use std::sync::Arc;
 
@@ -529,7 +526,7 @@ mod tests {
         }
 
         let mut bb = Int32BufferBuilder::new(7);
-        bb.append_slice(&[4, 7, 6, 3, 2, 8, 9]).unwrap();
+        bb.append_slice(&[4, 7, 6, 3, 2, 8, 9]);
         let expected_buffer = bb.finish();
         assert_eq!(
             expected_buffer,
@@ -617,7 +614,7 @@ mod tests {
 
         // Verify result record data
         let mut bb = Int32BufferBuilder::new(7);
-        bb.append_slice(&[0, 7, 0, 6, 3, 0, 8]).unwrap();
+        bb.append_slice(&[0, 7, 0, 6, 3, 0, 8]);
         let expected_buffer = bb.finish();
         assert_eq!(
             expected_buffer,
@@ -626,8 +623,7 @@ mod tests {
 
         // Verify result def levels
         let mut bb = Int16BufferBuilder::new(7);
-        bb.append_slice(&[1i16, 2i16, 0i16, 2i16, 2i16, 0i16, 2i16])
-            .unwrap();
+        bb.append_slice(&[1i16, 2i16, 0i16, 2i16, 2i16, 0i16, 2i16]);
         let expected_def_levels = bb.finish();
         assert_eq!(
             Some(expected_def_levels),
@@ -636,8 +632,7 @@ mod tests {
 
         // Verify bitmap
         let mut bb = BooleanBufferBuilder::new(7);
-        bb.append_slice(&[false, true, false, true, true, false, true])
-            .unwrap();
+        bb.append_slice(&[false, true, false, true, true, false, true]);
         let expected_bitmap = Bitmap::from(bb.finish());
         assert_eq!(
             Some(expected_bitmap),
@@ -727,7 +722,7 @@ mod tests {
 
         // Verify result record data
         let mut bb = Int32BufferBuilder::new(9);
-        bb.append_slice(&[4, 0, 0, 7, 6, 3, 2, 8, 9]).unwrap();
+        bb.append_slice(&[4, 0, 0, 7, 6, 3, 2, 8, 9]);
         let expected_buffer = bb.finish();
         assert_eq!(
             expected_buffer,
@@ -736,8 +731,7 @@ mod tests {
 
         // Verify result def levels
         let mut bb = Int16BufferBuilder::new(9);
-        bb.append_slice(&[2i16, 0i16, 1i16, 2i16, 2i16, 2i16, 2i16, 2i16, 2i16])
-            .unwrap();
+        bb.append_slice(&[2i16, 0i16, 1i16, 2i16, 2i16, 2i16, 2i16, 2i16, 2i16]);
         let expected_def_levels = bb.finish();
         assert_eq!(
             Some(expected_def_levels),
@@ -746,8 +740,7 @@ mod tests {
 
         // Verify bitmap
         let mut bb = BooleanBufferBuilder::new(9);
-        bb.append_slice(&[true, false, false, true, true, true, true, true, true])
-            .unwrap();
+        bb.append_slice(&[true, false, false, true, true, true, true, true, true]);
         let expected_bitmap = Bitmap::from(bb.finish());
         assert_eq!(
             Some(expected_bitmap),