Continued: Use Arc<[Buffer]> instead of raw Vec<Buffer> in GenericByteViewArray for faster slice

arrow-array/Cargo.toml

@@ -64,7 +64,7 @@ name = "occupancy"
 harness = false
 
 [[bench]]
-name = "gc_view_types"
+name = "view_types"
 harness = false
 
 [[bench]]

arrow-array/benches/gc_view_types.rs → arrow-array/benches/view_types.rs

@@ -43,6 +43,12 @@ fn criterion_benchmark(c: &mut Criterion) {
             hint::black_box(sliced.gc());
         });
     });
+
+    c.bench_function("view types slice", |b| {
+        b.iter(|| {
+            black_box(array.slice(0, 100_000 / 2));
+        });
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);

arrow-array/src/array/byte_view_array.rs

@@ -20,7 +20,9 @@ use crate::builder::{ArrayBuilder, GenericByteViewBuilder};
 use crate::iterator::ArrayIter;
 use crate::types::bytes::ByteArrayNativeType;
 use crate::types::{BinaryViewType, ByteViewType, StringViewType};
-use crate::{Array, ArrayAccessor, ArrayRef, GenericByteArray, OffsetSizeTrait, Scalar};
+use crate::{
+    Array, ArrayAccessor, ArrayRef, GenericByteArray, OffsetSizeTrait, Scalar, ViewBuffers,
+};
 use arrow_buffer::{ArrowNativeType, Buffer, NullBuffer, ScalarBuffer};
 use arrow_data::{ArrayData, ArrayDataBuilder, ByteView};
 use arrow_schema::{ArrowError, DataType};
@@ -162,7 +164,7 @@ use super::ByteArrayType;
 pub struct GenericByteViewArray<T: ByteViewType + ?Sized> {
     data_type: DataType,
     views: ScalarBuffer<u128>,
-    buffers: Vec<Buffer>,
+    buffers: Arc<[Buffer]>,
     phantom: PhantomData<T>,
     nulls: Option<NullBuffer>,
 }
@@ -185,7 +187,11 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
     /// # Panics
     ///
     /// Panics if [`GenericByteViewArray::try_new`] returns an error
-    pub fn new(views: ScalarBuffer<u128>, buffers: Vec<Buffer>, nulls: Option<NullBuffer>) -> Self {
+    pub fn new(
+        views: ScalarBuffer<u128>,
+        buffers: impl Into<ViewBuffers>,
+        nulls: Option<NullBuffer>,
+    ) -> Self {
         Self::try_new(views, buffers, nulls).unwrap()
     }
 
@@ -197,9 +203,11 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
     /// * [ByteViewType::validate] fails
     pub fn try_new(
         views: ScalarBuffer<u128>,
-        buffers: Vec<Buffer>,
+        buffers: impl Into<ViewBuffers>,
         nulls: Option<NullBuffer>,
     ) -> Result<Self, ArrowError> {
+        let buffers: Arc<[Buffer]> = buffers.into().0;
+
         T::validate(&views, &buffers)?;
 
         if let Some(n) = nulls.as_ref() {
@@ -229,7 +237,7 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
     /// Safe if [`Self::try_new`] would not error
     pub unsafe fn new_unchecked(
         views: ScalarBuffer<u128>,
-        buffers: Vec<Buffer>,
+        buffers: impl Into<ViewBuffers>,
         nulls: Option<NullBuffer>,
     ) -> Self {
         if cfg!(feature = "force_validate") {
@@ -240,7 +248,7 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
             data_type: T::DATA_TYPE,
             phantom: Default::default(),
             views,
-            buffers,
+            buffers: buffers.into().0,
             nulls,
         }
     }
@@ -250,7 +258,7 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
         Self {
             data_type: T::DATA_TYPE,
             views: vec![0; len].into(),
-            buffers: vec![],
+            buffers: vec![].into(),
             nulls: Some(NullBuffer::new_null(len)),
             phantom: Default::default(),
         }
@@ -276,7 +284,7 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
     }
 
     /// Deconstruct this array into its constituent parts
-    pub fn into_parts(self) -> (ScalarBuffer<u128>, Vec<Buffer>, Option<NullBuffer>) {
+    pub fn into_parts(self) -> (ScalarBuffer<u128>, Arc<[Buffer]>, Option<NullBuffer>) {
         (self.views, self.buffers, self.nulls)
     }
 
@@ -607,8 +615,9 @@ impl<T: ByteViewType + ?Sized> Array for GenericByteViewArray<T> {
 
     fn shrink_to_fit(&mut self) {
         self.views.shrink_to_fit();
-        self.buffers.iter_mut().for_each(|b| b.shrink_to_fit());
-        self.buffers.shrink_to_fit();
+        if let Some(buffers) = Arc::get_mut(&mut self.buffers) {
+            buffers.iter_mut().for_each(|b| b.shrink_to_fit());
+        }
         if let Some(nulls) = &mut self.nulls {
             nulls.shrink_to_fit();
         }
@@ -670,7 +679,7 @@ impl<T: ByteViewType + ?Sized> From<ArrayData> for GenericByteViewArray<T> {
         Self {
             data_type: T::DATA_TYPE,
             views,
-            buffers,
+            buffers: buffers.into(),
             nulls: value.nulls().cloned(),
             phantom: Default::default(),
         }
@@ -734,12 +743,20 @@ where
 }
 
 impl<T: ByteViewType + ?Sized> From<GenericByteViewArray<T>> for ArrayData {
-    fn from(mut array: GenericByteViewArray<T>) -> Self {
+    fn from(array: GenericByteViewArray<T>) -> Self {
         let len = array.len();
-        array.buffers.insert(0, array.views.into_inner());
+        let new_buffers = {
+            let mut buffers = Vec::with_capacity(array.buffers.len() + 1);
+            buffers.push(array.views.into_inner());
+            for buffer in array.buffers.iter() {
+                buffers.push(buffer.clone());
+            }
+            buffers
+        };
+
         let builder = ArrayDataBuilder::new(T::DATA_TYPE)
             .len(len)
-            .buffers(array.buffers)
+            .buffers(new_buffers)
             .nulls(array.nulls);
 
         unsafe { builder.build_unchecked() }
@@ -795,7 +812,7 @@ impl BinaryViewArray {
     /// # Safety
     /// Caller is responsible for ensuring that items in array are utf8 data.
     pub unsafe fn to_string_view_unchecked(self) -> StringViewArray {
-        StringViewArray::new_unchecked(self.views, self.buffers, self.nulls)
+        StringViewArray::new_unchecked(self.views, ViewBuffers(self.buffers), self.nulls)
     }
 }
 
@@ -827,7 +844,7 @@ pub type StringViewArray = GenericByteViewArray<StringViewType>;
 impl StringViewArray {
     /// Convert the [`StringViewArray`] to [`BinaryViewArray`]
     pub fn to_binary_view(self) -> BinaryViewArray {
-        unsafe { BinaryViewArray::new_unchecked(self.views, self.buffers, self.nulls) }
+        unsafe { BinaryViewArray::new_unchecked(self.views, ViewBuffers(self.buffers), self.nulls) }
     }
 
     /// Returns true if all data within this array is ASCII

arrow-array/src/lib.rs

@@ -259,6 +259,8 @@ pub mod temporal_conversions;
 pub mod timezone;
 mod trusted_len;
 pub mod types;
+mod view_buffers;
+pub use view_buffers::ViewBuffers;
 
 #[cfg(test)]
 mod tests {

arrow-array/src/view_buffers.rs

@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use arrow_buffer::Buffer;
+
+/// A cheaply cloneable, owned slice of [`Buffer`]
+///
+/// Similar to `Arc<Vec<Buffer>>` or `Arc<[Buffer]>`
+#[derive(Clone, Debug)]
+pub struct ViewBuffers(pub(crate) Arc<[Buffer]>);
+
+impl FromIterator<Buffer> for ViewBuffers {
+    fn from_iter<T: IntoIterator<Item = Buffer>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl From<Vec<Buffer>> for ViewBuffers {
+    fn from(value: Vec<Buffer>) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<&[Buffer]> for ViewBuffers {
+    fn from(value: &[Buffer]) -> Self {
+        Self(value.into())
+    }
+}