Add BinaryView::make_view method (#2664)

Author: robert3005

encodings/dict/src/builders/bytes.rs

@@ -53,15 +53,12 @@ impl BytesDictBuilder {
             )
             .or_insert_with(|| {
                 let next_code = self.views.len() as u64;
-                if val.len() <= BinaryView::MAX_INLINED_SIZE {
-                    self.views.push(BinaryView::new_inlined(val));
-                } else {
-                    self.views.push(BinaryView::new_view(
-                        u32::try_from(val.len()).vortex_unwrap(),
-                        val[0..4].try_into().vortex_unwrap(),
-                        0,
-                        u32::try_from(self.values.len()).vortex_unwrap(),
-                    ));
+                self.views.push(BinaryView::make_view(
+                    val,
+                    0,
+                    u32::try_from(self.values.len()).vortex_unwrap(),
+                ));
+                if val.len() > BinaryView::MAX_INLINED_SIZE {
                     self.values.extend_from_slice(val);
                 }
                 next_code

encodings/fsst/src/canonical.rs

@@ -1,4 +1,3 @@
-use arrow_array::builder::make_view;
 use fsst::Decompressor;
 use vortex_array::arrays::{BinaryView, VarBinArray, VarBinViewArray};
 use vortex_array::builders::{ArrayBuilder, VarBinViewBuilder};
@@ -78,7 +77,7 @@ fn fsst_into_varbin_view(
         let mut offset = 0;
         for len in uncompressed_lens_array.as_slice::<$P>() {
             let len = *len as usize;
-            let view = make_view(
+            let view = BinaryView::make_view(
                 &uncompressed_bytes[offset..][..len],
                 block_offset,
                 offset as u32,

vortex-array/src/arrays/constant/canonical.rs

@@ -1,4 +1,3 @@
-use arrow_array::builder::make_view;
 use arrow_buffer::BooleanBuffer;
 use vortex_buffer::{Buffer, BufferMut, buffer};
 use vortex_dtype::{DType, Nullability, PType, match_each_native_ptype};
@@ -114,7 +113,7 @@ fn canonical_byte_view(
         Some(scalar_bytes) => {
             // Create a view to hold the scalar bytes.
             // If the scalar cannot be inlined, allocate a single buffer large enough to hold it.
-            let view = BinaryView::from(make_view(scalar_bytes, 0, 0));
+            let view = BinaryView::make_view(scalar_bytes, 0, 0);
             let mut buffers = Vec::new();
             if scalar_bytes.len() >= BinaryView::MAX_INLINED_SIZE {
                 buffers.push(Buffer::copy_from(scalar_bytes));

vortex-array/src/arrays/varbinview/mod.rs

@@ -38,17 +38,12 @@ pub struct Inlined {
 }
 
 impl Inlined {
-    pub fn new(value: &[u8]) -> Self {
-        assert!(
-            value.len() <= BinaryView::MAX_INLINED_SIZE,
-            "Inlined strings must be shorter than 13 characters, {} given",
-            value.len()
-        );
+    fn new<const N: usize>(value: &[u8]) -> Self {
         let mut inlined = Self {
-            size: value.len().try_into().vortex_unwrap(),
+            size: N.try_into().vortex_unwrap(),
             data: [0u8; BinaryView::MAX_INLINED_SIZE],
         };
-        inlined.data[..value.len()].copy_from_slice(value);
+        inlined.data[..N].copy_from_slice(&value[..N]);
         inlined
     }
 
@@ -120,29 +115,82 @@ assert_eq_align!(BinaryView, u128);
 impl BinaryView {
     pub const MAX_INLINED_SIZE: usize = 12;
 
-    pub fn empty_view() -> Self {
-        Self {
-            inlined: Inlined::new(&[]),
+    /// Create a view from a value, block and offset
+    ///
+    /// Depending on the length of the provided value either a new inlined
+    /// or a reference view will be constructed.
+    ///
+    /// Adapted from arrow-rs <https://github.com/apache/arrow-rs/blob/f4fde769ab6e1a9b75f890b7f8b47bc22800830b/arrow-array/src/builder/generic_bytes_view_builder.rs#L524>
+    /// Explicitly enumerating inlined view produces code that avoids calling generic `ptr::copy_non_interleave` that's slower than explicit stores
+    #[inline(never)]
+    pub fn make_view(value: &[u8], block: u32, offset: u32) -> Self {
+        match value.len() {
+            0 => Self {
+                inlined: Inlined::new::<0>(value),
+            },
+            1 => Self {
+                inlined: Inlined::new::<1>(value),
+            },
+            2 => Self {
+                inlined: Inlined::new::<2>(value),
+            },
+            3 => Self {
+                inlined: Inlined::new::<3>(value),
+            },
+            4 => Self {
+                inlined: Inlined::new::<4>(value),
+            },
+            5 => Self {
+                inlined: Inlined::new::<5>(value),
+            },
+            6 => Self {
+                inlined: Inlined::new::<6>(value),
+            },
+            7 => Self {
+                inlined: Inlined::new::<7>(value),
+            },
+            8 => Self {
+                inlined: Inlined::new::<8>(value),
+            },
+            9 => Self {
+                inlined: Inlined::new::<9>(value),
+            },
+            10 => Self {
+                inlined: Inlined::new::<10>(value),
+            },
+            11 => Self {
+                inlined: Inlined::new::<11>(value),
+            },
+            12 => Self {
+                inlined: Inlined::new::<12>(value),
+            },
+            _ => Self {
+                _ref: Ref::new(
+                    u32::try_from(value.len()).vortex_unwrap(),
+                    value[0..4].try_into().vortex_unwrap(),
+                    block,
+                    offset,
+                ),
+            },
         }
     }
 
+    /// Create a new empty view
+    #[inline]
+    pub fn empty_view() -> Self {
+        Self::new_inlined(&[])
+    }
+
+    /// Create a new inlined binary view
+    #[inline]
     pub fn new_inlined(value: &[u8]) -> Self {
         assert!(
             value.len() <= Self::MAX_INLINED_SIZE,
             "expected inlined value to be <= 12 bytes, was {}",
             value.len()
         );
 
-        Self {
-            inlined: Inlined::new(value),
-        }
-    }
-
-    /// Create a new view over bytes stored in a block.
-    pub fn new_view(len: u32, prefix: [u8; 4], block: u32, offset: u32) -> Self {
-        Self {
-            _ref: Ref::new(len, prefix, block, offset),
-        }
+        Self::make_view(value, 0, 0)
     }
 
     #[inline]
@@ -183,12 +231,14 @@ impl BinaryView {
         } else {
             // Referencing views must have their buffer_index adjusted with new offsets
             let view_ref = self.as_view();
-            BinaryView::new_view(
-                self.len(),
-                *view_ref.prefix(),
-                offset + view_ref.buffer_index(),
-                view_ref.offset(),
-            )
+            Self {
+                _ref: Ref::new(
+                    self.len(),
+                    *view_ref.prefix(),
+                    offset + view_ref.buffer_index(),
+                    view_ref.offset(),
+                ),
+            }
         }
     }
 }

vortex-array/src/builders/varbinview.rs

@@ -40,27 +40,24 @@ impl VarBinViewBuilder {
     }
 
     fn append_value_view(&mut self, value: &[u8]) {
-        let v: &[u8] = value;
         let length =
-            u32::try_from(v.len()).vortex_expect("cannot have a single string >2^32 in length");
+            u32::try_from(value.len()).vortex_expect("cannot have a single string >2^32 in length");
         if length <= 12 {
-            self.views_builder.push(BinaryView::new_inlined(v));
+            self.views_builder.push(BinaryView::make_view(value, 0, 0));
             return;
         }
 
-        let required_cap = self.in_progress.len() + v.len();
+        let required_cap = self.in_progress.len() + value.len();
         if self.in_progress.capacity() < required_cap {
             self.flush_in_progress();
-            let to_reserve = max(v.len(), VarBinViewBuilder::BLOCK_SIZE as usize);
+            let to_reserve = max(value.len(), VarBinViewBuilder::BLOCK_SIZE as usize);
             self.in_progress.reserve(to_reserve);
         };
-        let offset = u32::try_from(self.in_progress.len()).vortex_expect("too many buffers");
-        self.in_progress.extend_from_slice(v);
 
-        let view = BinaryView::new_view(
-            length,
-            // inline the first 4 bytes of the view
-            v[0..4].try_into().vortex_expect("length already checked"),
+        let offset = u32::try_from(self.in_progress.len()).vortex_expect("too many buffers");
+        self.in_progress.extend_from_slice(value);
+        let view = BinaryView::make_view(
+            value,
             // buffer offset
             u32::try_from(self.completed.len()).vortex_expect("too many buffers"),
             offset,