refactor: bytes view calc total_bytes_len lazy. (#19056)

* refactor: bytes view calc total_bytes_len lazy.

* update tests.

Author: youngsofun

src/common/column/src/binview/builder.rs

@@ -73,8 +73,8 @@ impl<T: ViewType + ?Sized> From<BinaryViewColumnBuilder<T>> for BinaryViewColumn
         Self::new_unchecked(
             value.views.into(),
             Arc::from(value.completed_buffers),
-            value.total_bytes_len,
-            value.total_buffer_len,
+            Some(value.total_bytes_len),
+            Some(value.total_buffer_len),
         )
     }
 }

src/common/column/src/binview/mod.rs

@@ -22,6 +22,7 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use arrow_data::ArrayData;
 use arrow_data::ArrayDataBuilder;
@@ -115,20 +116,24 @@ pub struct BinaryViewColumnGeneric<T: ViewType + ?Sized> {
     buffers: Arc<[Buffer<u8>]>,
     phantom: PhantomData<T>,
     /// Total bytes length if we would concat them all
-    total_bytes_len: usize,
+    /// Initialized lazily when needed.
+    total_bytes_len: OnceLock<usize>,
     /// Total bytes in the buffer (exclude remaining capacity)
-    total_buffer_len: usize,
+    /// Initialized lazily when needed.
+    total_buffer_len: OnceLock<usize>,
 }
 
 impl<T: ViewType + ?Sized> Clone for BinaryViewColumnGeneric<T> {
     fn clone(&self) -> Self {
+        let total_bytes_len = self.total_bytes_len.get().copied();
+        let total_buffer_len = self.total_buffer_len.get().copied();
         Self {
             views: self.views.clone(),
             buffers: self.buffers.clone(),
 
             phantom: Default::default(),
-            total_bytes_len: self.total_bytes_len,
-            total_buffer_len: self.total_buffer_len,
+            total_bytes_len: Self::init_cache(total_bytes_len),
+            total_buffer_len: Self::init_cache(total_buffer_len),
         }
     }
 }
@@ -138,29 +143,41 @@ unsafe impl<T: ViewType + ?Sized> Send for BinaryViewColumnGeneric<T> {}
 unsafe impl<T: ViewType + ?Sized> Sync for BinaryViewColumnGeneric<T> {}
 
 impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
+    fn init_cache(value: Option<usize>) -> OnceLock<usize> {
+        let cache = OnceLock::new();
+        if let Some(v) = value {
+            let _ = cache.set(v);
+        }
+        cache
+    }
+
     pub fn new_unchecked(
         views: Buffer<View>,
         buffers: Arc<[Buffer<u8>]>,
 
-        total_bytes_len: usize,
-        total_buffer_len: usize,
+        total_bytes_len: Option<usize>,
+        total_buffer_len: Option<usize>,
     ) -> Self {
         #[cfg(debug_assertions)]
         {
-            let total = views.iter().map(|v| v.length as usize).sum::<usize>();
-            assert_eq!(total, total_bytes_len);
+            if let Some(total_bytes_len) = total_bytes_len {
+                let total = views.iter().map(|v| v.length as usize).sum::<usize>();
+                assert_eq!(total, total_bytes_len);
+            }
 
-            let total = buffers.iter().map(|v| v.len()).sum::<usize>();
-            assert_eq!(total, total_buffer_len);
+            if let Some(total_buffer_len) = total_buffer_len {
+                let total = buffers.iter().map(|v| v.len()).sum::<usize>();
+                assert_eq!(total, total_buffer_len);
+            }
         }
 
         Self {
             views,
             buffers,
 
             phantom: Default::default(),
-            total_bytes_len,
-            total_buffer_len,
+            total_bytes_len: Self::init_cache(total_bytes_len),
+            total_buffer_len: Self::init_cache(total_buffer_len),
         }
     }
 
@@ -173,9 +190,8 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
         total_buffer_len: Option<usize>,
     ) -> Self {
         let total_buffer_len =
-            total_buffer_len.unwrap_or(buffers.iter().map(|v| v.len()).sum::<usize>());
-        let total_bytes_len = views.iter().map(|v| v.length as usize).sum::<usize>();
-        Self::new_unchecked(views, buffers, total_bytes_len, total_buffer_len)
+            total_buffer_len.unwrap_or_else(|| buffers.iter().map(|v| v.len()).sum::<usize>());
+        Self::new_unchecked(views, buffers, None, Some(total_buffer_len))
     }
 
     pub fn data_buffers(&self) -> &Arc<[Buffer<u8>]> {
@@ -212,7 +228,7 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
     /// Creates an empty [`BinaryViewColumnGeneric`], i.e. whose `.len` is zero.
     #[inline]
     pub fn new_empty() -> Self {
-        Self::new_unchecked(Buffer::new(), Arc::from([]), 0, 0)
+        Self::new_unchecked(Buffer::new(), Arc::from([]), Some(0), Some(0))
     }
 
     /// Returns the element at index `i`
@@ -293,11 +309,13 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
 
     /// Get the total length of bytes that it would take to concatenate all binary/str values in this array.
     pub fn total_bytes_len(&self) -> usize {
-        self.total_bytes_len
+        *self
+            .total_bytes_len
+            .get_or_init(|| self.views.iter().map(|v| v.length as usize).sum::<usize>())
     }
 
     pub fn memory_size(&self) -> usize {
-        self.total_buffer_len + self.len() * 16
+        self.total_buffer_len() + self.len() * 16
     }
 
     fn total_unshared_buffer_len(&self) -> usize {
@@ -317,7 +335,9 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
 
     /// Get the length of bytes that are stored in the variadic buffers.
     pub fn total_buffer_len(&self) -> usize {
-        self.total_buffer_len
+        *self
+            .total_buffer_len
+            .get_or_init(|| self.buffers.iter().map(|v| v.len()).sum::<usize>())
     }
 
     #[inline(always)]
@@ -397,15 +417,15 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
     unsafe fn slice_unchecked(&mut self, offset: usize, length: usize) {
         debug_assert!(offset + length <= self.len());
         self.views.slice_unchecked(offset, length);
-        self.total_bytes_len = self.views.iter().map(|v| v.length as usize).sum::<usize>();
+        self.total_bytes_len = OnceLock::new();
     }
 
     impl_sliced!();
 
     pub fn maybe_gc(self) -> Self {
         const GC_MINIMUM_SAVINGS: usize = 16 * 1024; // At least 16 KiB.
 
-        if self.total_buffer_len <= GC_MINIMUM_SAVINGS {
+        if self.total_buffer_len() <= GC_MINIMUM_SAVINGS {
             return self;
         }
 
@@ -435,6 +455,8 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
     }
 
     pub fn make_mut(self) -> BinaryViewColumnBuilder<T> {
+        let total_bytes_len = self.total_bytes_len();
+        let total_buffer_len = self.total_buffer_len();
         let views = self.views.make_mut();
         let completed_buffers = self.buffers.to_vec();
 
@@ -444,8 +466,8 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
             in_progress_buffer: vec![],
 
             phantom: Default::default(),
-            total_bytes_len: self.total_bytes_len,
-            total_buffer_len: self.total_buffer_len,
+            total_bytes_len,
+            total_buffer_len,
         }
     }
 
@@ -454,26 +476,29 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
         use Either::*;
         let is_unique = (Arc::strong_count(&self.buffers) + Arc::weak_count(&self.buffers)) == 1;
 
+        let total_bytes_len = self.total_bytes_len();
+        let total_buffer_len = self.total_buffer_len();
+
         match (self.views.into_mut(), is_unique) {
             (Right(views), true) => Right(BinaryViewColumnBuilder {
                 views,
                 completed_buffers: self.buffers.to_vec(),
                 in_progress_buffer: vec![],
                 phantom: Default::default(),
-                total_bytes_len: self.total_bytes_len,
-                total_buffer_len: self.total_buffer_len,
+                total_bytes_len,
+                total_buffer_len,
             }),
             (Right(views), false) => Left(Self::new_unchecked(
                 views.into(),
                 self.buffers,
-                self.total_bytes_len,
-                self.total_buffer_len,
+                Some(total_bytes_len),
+                Some(total_buffer_len),
             )),
             (Left(views), _) => Left(Self::new_unchecked(
                 views,
                 self.buffers,
-                self.total_bytes_len,
-                self.total_buffer_len,
+                Some(total_bytes_len),
+                Some(total_buffer_len),
             )),
         }
     }
@@ -538,8 +563,8 @@ impl BinaryViewColumn {
         Utf8ViewColumn::new_unchecked(
             self.views.clone(),
             self.buffers.clone(),
-            self.total_bytes_len,
-            self.total_buffer_len,
+            Some(self.total_bytes_len()),
+            Some(self.total_buffer_len()),
         )
     }
 }
@@ -549,8 +574,8 @@ impl Utf8ViewColumn {
         BinaryViewColumn::new_unchecked(
             self.views.clone(),
             self.buffers.clone(),
-            self.total_bytes_len,
-            self.total_buffer_len,
+            Some(self.total_bytes_len()),
+            Some(self.total_buffer_len()),
         )
     }
 

src/common/column/tests/it/binview/mod.rs

@@ -43,8 +43,8 @@ fn basics_string_view() {
     let array2 = Utf8ViewColumn::new_unchecked(
         array.views().clone(),
         array.data_buffers().clone(),
-        array.total_bytes_len(),
-        array.total_buffer_len(),
+        Some(array.total_bytes_len()),
+        Some(array.total_buffer_len()),
     );
 
     assert_eq!(array, array2);
@@ -83,8 +83,8 @@ fn basics_binary_view() {
     let array2 = BinaryViewColumn::new_unchecked(
         array.views().clone(),
         array.data_buffers().clone(),
-        array.total_bytes_len(),
-        array.total_buffer_len(),
+        Some(array.total_bytes_len()),
+        Some(array.total_buffer_len()),
     );
 
     assert_eq!(array, array2);

src/query/expression/src/expression.rs

@@ -1133,14 +1133,14 @@ mod tests {
 
     #[test]
     fn test_size() {
-        assert_eq!(size_of::<Expr>(), 144);
-        assert_eq!(size_of::<Constant>(), 128);
+        assert_eq!(size_of::<Expr>(), 160);
+        assert_eq!(size_of::<Constant>(), 144);
         assert_eq!(size_of::<ColumnRef>(), 72);
         assert_eq!(size_of::<Cast>(), 48);
         assert_eq!(size_of::<FunctionCall>(), 104);
         assert_eq!(size_of::<LambdaFunctionCall>(), 120);
 
-        assert_eq!(size_of::<RawExpr>(), 128);
-        assert_eq!(size_of::<RemoteExpr>(), 128);
+        assert_eq!(size_of::<RawExpr>(), 144);
+        assert_eq!(size_of::<RemoteExpr>(), 144);
     }
 }