fix: http handler cut block to pages using memory size after gc. (#19071)

youngsofun · web-flow · commit 13efc1f10b22 · 2025-12-08T15:32:51.000+08:00
* Datablock add fn memory_size_with_options

* fix: http handler cut block to pages using memory size after gc.

* Column::memory_size add arg gc.

* Column::memory_size add arg gc.
diff --git a/src/common/column/src/binview/mod.rs b/src/common/column/src/binview/mod.rs
@@ -314,8 +314,12 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {
             .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
+    pub fn memory_size(&self, gc: bool) -> usize {
+        if gc {
+            self.total_bytes_len() + self.len() * 16
+        } else {
+            self.total_buffer_len() + self.len() * 16
+        }
     }
 
     fn total_unshared_buffer_len(&self) -> usize {
diff --git a/src/common/column/tests/it/binview/mod.rs b/src/common/column/tests/it/binview/mod.rs
@@ -151,15 +151,15 @@ fn test_slice() {
     ];
 
     let array: Utf8ViewColumn = data.into_iter().collect();
-    assert_eq!(array.memory_size(), 156);
+    assert_eq!(array.memory_size(false), 156);
 
     let a3 = array.sliced(2, 3);
     assert_eq!(a3.into_iter().collect::<Vec<_>>(), vec![
         "databend",
         "yyyyyyyyyyyyyyyyyyyyy",
         "zzzzzzzzzzzzzzzzzzzzz",
     ]);
-    assert_eq!(a3.memory_size(), 108);
+    assert_eq!(a3.memory_size(false), 108);
 }
 
 #[test]
diff --git a/src/query/expression/src/block.rs b/src/query/expression/src/block.rs
@@ -98,7 +98,14 @@ impl BlockEntry {
     pub fn memory_size(&self) -> usize {
         match self {
             BlockEntry::Const(scalar, _, _) => scalar.as_ref().memory_size(),
-            BlockEntry::Column(column) => column.memory_size(),
+            BlockEntry::Column(column) => column.memory_size(false),
+        }
+    }
+
+    pub fn memory_size_with_options(&self, gc: bool) -> usize {
+        match self {
+            BlockEntry::Const(scalar, _, _) => scalar.as_ref().memory_size(),
+            BlockEntry::Column(column) => column.memory_size(gc),
         }
     }
 
diff --git a/src/query/expression/src/types.rs b/src/query/expression/src/types.rs
@@ -607,7 +607,8 @@ pub trait AccessType: Debug + Clone + PartialEq + Sized + 'static {
         std::mem::size_of::<Self::Scalar>()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        let _ = gc;
         Self::column_len(col) * std::mem::size_of::<Self::Scalar>()
     }
 
diff --git a/src/query/expression/src/types/any.rs b/src/query/expression/src/types/any.rs
@@ -83,8 +83,8 @@ impl AccessType for AnyType {
         scalar.memory_size()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     #[inline(always)]
diff --git a/src/query/expression/src/types/array.rs b/src/query/expression/src/types/array.rs
@@ -101,11 +101,11 @@ impl<T: AccessType> AccessType for ArrayType<T> {
     }
 
     fn scalar_memory_size(scalar: &Self::ScalarRef<'_>) -> usize {
-        <T as AccessType>::column_memory_size(scalar)
+        <T as AccessType>::column_memory_size(scalar, false)
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     fn compare(a: T::Column, b: T::Column) -> Ordering {
@@ -269,8 +269,8 @@ impl<T: AccessType> ArrayColumn<T> {
         }
     }
 
-    pub fn memory_size(&self) -> usize {
-        T::column_memory_size(&self.underlying_column()) + self.offsets.len() * 8
+    pub fn memory_size(&self, gc: bool) -> usize {
+        T::column_memory_size(&self.underlying_column(), gc) + self.offsets.len() * 8
     }
 
     // Note: if the array column has been sliced, the number of values may not match the offsets.
diff --git a/src/query/expression/src/types/binary.rs b/src/query/expression/src/types/binary.rs
@@ -100,7 +100,7 @@ impl AccessType for BinaryType {
         scalar.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.data().len() + col.offsets().len() * 8
     }
 
diff --git a/src/query/expression/src/types/bitmap.rs b/src/query/expression/src/types/bitmap.rs
@@ -100,7 +100,7 @@ impl AccessType for BitmapType {
         scalar.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.memory_size()
     }
 
diff --git a/src/query/expression/src/types/compute_view.rs b/src/query/expression/src/types/compute_view.rs
@@ -111,7 +111,7 @@ where
         std::mem::size_of::<F>()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         F::column_len(col) * std::mem::size_of::<F>()
     }
 
diff --git a/src/query/expression/src/types/generic.rs b/src/query/expression/src/types/generic.rs
@@ -86,8 +86,8 @@ impl<const INDEX: usize> AccessType for GenericType<INDEX> {
         scalar.memory_size()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     #[inline(always)]
diff --git a/src/query/expression/src/types/geography.rs b/src/query/expression/src/types/geography.rs
@@ -175,7 +175,7 @@ impl AccessType for GeographyType {
         scalar.0.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.memory_size()
     }
 
diff --git a/src/query/expression/src/types/geometry.rs b/src/query/expression/src/types/geometry.rs
@@ -103,7 +103,7 @@ impl AccessType for GeometryType {
         scalar.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.memory_size()
     }
 
diff --git a/src/query/expression/src/types/map.rs b/src/query/expression/src/types/map.rs
@@ -111,8 +111,8 @@ impl<K: AccessType, V: AccessType> AccessType for KvPair<K, V> {
         K::scalar_memory_size(k) + V::scalar_memory_size(v)
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     #[inline(always)]
@@ -289,8 +289,8 @@ impl<K: AccessType, V: AccessType> KvColumn<K, V> {
         }
     }
 
-    pub fn memory_size(&self) -> usize {
-        K::column_memory_size(&self.keys) + V::column_memory_size(&self.values)
+    pub fn memory_size(&self, gc: bool) -> usize {
+        K::column_memory_size(&self.keys, gc) + V::column_memory_size(&self.values, gc)
     }
 }
 
@@ -501,8 +501,8 @@ impl<K: AccessType, V: AccessType> AccessType for MapType<K, V> {
         MapInternal::<K, V>::scalar_memory_size(scalar)
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        MapInternal::<K, V>::column_memory_size(col)
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        MapInternal::<K, V>::column_memory_size(col, gc)
     }
 
     #[inline(always)]
diff --git a/src/query/expression/src/types/nullable.rs b/src/query/expression/src/types/nullable.rs
@@ -119,8 +119,8 @@ impl<T: AccessType> AccessType for NullableType<T> {
         }
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     // Null default lastly
@@ -350,8 +350,8 @@ impl<T: AccessType> NullableColumn<T> {
         }
     }
 
-    pub fn memory_size(&self) -> usize {
-        T::column_memory_size(&self.column) + self.validity.as_slice().0.len()
+    pub fn memory_size(&self, gc: bool) -> usize {
+        T::column_memory_size(&self.column, gc) + self.validity.as_slice().0.len()
     }
 
     pub fn destructure(self) -> (T::Column, Bitmap) {
diff --git a/src/query/expression/src/types/simple_type.rs b/src/query/expression/src/types/simple_type.rs
@@ -147,7 +147,7 @@ impl<T: SimpleType> AccessType for SimpleValueType<T> {
         std::mem::size_of::<Self::Scalar>()
     }
 
-    fn column_memory_size(buffer: &Buffer<Self::Scalar>) -> usize {
+    fn column_memory_size(buffer: &Buffer<Self::Scalar>, _gc: bool) -> usize {
         buffer.len() * std::mem::size_of::<Self::Scalar>()
     }
 
diff --git a/src/query/expression/src/types/string.rs b/src/query/expression/src/types/string.rs
@@ -100,8 +100,8 @@ impl AccessType for StringType {
         scalar.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
-        col.memory_size()
+    fn column_memory_size(col: &Self::Column, gc: bool) -> usize {
+        col.memory_size(gc)
     }
 
     #[inline(always)]
diff --git a/src/query/expression/src/types/variant.rs b/src/query/expression/src/types/variant.rs
@@ -120,7 +120,7 @@ impl AccessType for VariantType {
         scalar.len()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.memory_size()
     }
 
diff --git a/src/query/expression/src/types/vector.rs b/src/query/expression/src/types/vector.rs
@@ -107,7 +107,7 @@ impl AccessType for VectorType {
         scalar.memory_size()
     }
 
-    fn column_memory_size(col: &Self::Column) -> usize {
+    fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {
         col.memory_size()
     }
 
diff --git a/src/query/expression/src/types/zero_size_type.rs b/src/query/expression/src/types/zero_size_type.rs
@@ -103,7 +103,7 @@ impl<T: ZeroSizeType> AccessType for ZeroSizeValueType<T> {
         0
     }
 
-    fn column_memory_size(_: &usize) -> usize {
+    fn column_memory_size(_: &usize, _: bool) -> usize {
         std::mem::size_of::<usize>()
     }
 
diff --git a/src/query/expression/src/values.rs b/src/query/expression/src/values.rs
@@ -297,10 +297,10 @@ impl<T: AccessType> Value<T> {
         }
     }
 
-    pub fn memory_size(&self) -> usize {
+    pub fn memory_size(&self, gc: bool) -> usize {
         match self {
             Value::Scalar(scalar) => T::scalar_memory_size(&T::to_scalar_ref(scalar)),
-            Value::Column(c) => T::column_memory_size(c),
+            Value::Column(c) => T::column_memory_size(c, gc),
         }
     }
 
@@ -707,8 +707,8 @@ impl ScalarRef<'_> {
             ScalarRef::TimestampTz(_) => 16,
             ScalarRef::Date(_) => 4,
             ScalarRef::Interval(_) => 16,
-            ScalarRef::Array(col) => col.memory_size(),
-            ScalarRef::Map(col) => col.memory_size(),
+            ScalarRef::Array(col) => col.memory_size(false),
+            ScalarRef::Map(col) => col.memory_size(false),
             ScalarRef::Bitmap(b) => b.len(),
             ScalarRef::Tuple(scalars) => scalars.iter().map(|s| s.memory_size()).sum(),
             ScalarRef::Variant(buf) => buf.len(),
@@ -897,8 +897,8 @@ impl ScalarRef<'_> {
             ScalarRef::TimestampTz(_) => n * 16,
             ScalarRef::Date(_) => n * 4,
             ScalarRef::Interval(_) => n * 16,
-            ScalarRef::Array(col) => col.memory_size() * n + (n + 1) * 8,
-            ScalarRef::Map(col) => col.memory_size() * n + (n + 1) * 8,
+            ScalarRef::Array(col) => col.memory_size(false) * n + (n + 1) * 8,
+            ScalarRef::Map(col) => col.memory_size(false) * n + (n + 1) * 8,
             ScalarRef::Bitmap(b) => b.len() * n + (n + 1) * 8,
             ScalarRef::Tuple(fields) => {
                 let DataType::Tuple(fields_ty) = data_type else {
@@ -1754,7 +1754,7 @@ impl Column {
         }
     }
 
-    pub fn memory_size(&self) -> usize {
+    pub fn memory_size(&self, gc: bool) -> usize {
         match self {
             Column::Null { .. } => std::mem::size_of::<usize>(),
             Column::EmptyArray { .. } => std::mem::size_of::<usize>(),
@@ -1774,19 +1774,19 @@ impl Column {
             Column::Decimal(DecimalColumn::Decimal256(col, _)) => col.len() * 32,
             Column::Boolean(c) => c.as_slice().0.len(),
             Column::Binary(col) => col.memory_size(),
-            Column::String(col) => col.memory_size(),
+            Column::String(col) => col.memory_size(gc),
             Column::Timestamp(col) => col.len() * 8,
             Column::TimestampTz(col) => col.len() * 16,
             Column::Date(col) => col.len() * 4,
             Column::Interval(col) => col.len() * 16,
-            Column::Array(col) => col.memory_size(),
-            Column::Map(col) => col.memory_size(),
+            Column::Array(col) => col.memory_size(gc),
+            Column::Map(col) => col.memory_size(gc),
             Column::Bitmap(col) => col.memory_size(),
-            Column::Nullable(c) => c.column.memory_size() + c.validity.as_slice().0.len(),
-            Column::Tuple(fields) => fields.iter().map(|f| f.memory_size()).sum(),
+            Column::Nullable(c) => c.column.memory_size(gc) + c.validity.as_slice().0.len(),
+            Column::Tuple(fields) => fields.iter().map(|f| f.memory_size(gc)).sum(),
             Column::Variant(col) => col.memory_size(),
             Column::Geometry(col) => col.memory_size(),
-            Column::Geography(col) => GeographyType::column_memory_size(col),
+            Column::Geography(col) => GeographyType::column_memory_size(col, gc),
             Column::Vector(col) => col.memory_size(),
             Column::Opaque(col) => col.memory_size(),
         }
@@ -1810,7 +1810,7 @@ impl Column {
             Column::Decimal(DecimalColumn::Decimal128(col, _)) => col.len() * 16,
             Column::Decimal(DecimalColumn::Decimal256(col, _)) => col.len() * 32,
             Column::Interval(col) => col.len() * 16,
-            Column::Geography(col) => GeographyType::column_memory_size(col),
+            Column::Geography(col) => GeographyType::column_memory_size(col, false),
             Column::Boolean(c) => c.len(),
             // 8 * len + size of bytes
             Column::Binary(col)
diff --git a/src/query/expression/tests/it/block.rs b/src/query/expression/tests/it/block.rs
@@ -90,16 +90,16 @@ fn test_block_entry_memory_size() {
     assert_eq!(3, entry.memory_size());
 
     let col = StringType::from_data((0..10).map(|x| x.to_string()).collect::<Vec<_>>());
-    assert_eq!(col.memory_size(), 10 * 16);
+    assert_eq!(col.memory_size(false), 10 * 16);
 
     let array = ArrayColumn::<Int64Type>::new(
         Buffer::from_iter(0..10i64),
         Buffer::from(vec![0u64, 1, 3, 6, 10]),
     );
-    let total_memory_size = array.memory_size(); // 10 * 8 + 5 * 8 = 80 + 40 = 120
+    let total_memory_size = array.memory_size(false); // 10 * 8 + 5 * 8 = 80 + 40 = 120
     let expected = array
         .iter()
-        .map(|x| Int64Type::column_memory_size(&x))
+        .map(|x| Int64Type::column_memory_size(&x, false))
         .sum::<usize>()
         + (array.len() + 1) * 8;
     assert_eq!(total_memory_size, expected);
@@ -108,6 +108,6 @@ fn test_block_entry_memory_size() {
     let array3 = array.slice(2..4);
     assert_eq!(
         total_memory_size,
-        array2.memory_size() + array3.memory_size() - 8
+        array2.memory_size(false) + array3.memory_size(false) - 8
     );
 }
diff --git a/src/query/expression/tests/it/kernel.rs b/src/query/expression/tests/it/kernel.rs
@@ -625,7 +625,7 @@ fn assert_estimated_scalar_repeat_size(scalar: ScalarRef, num_rows: usize, ty: D
     let col = builder.build();
     assert_eq!(
         scalar.estimated_scalar_repeat_size(num_rows, &ty),
-        col.memory_size()
+        col.memory_size(false)
     );
 }
 
diff --git a/src/query/service/src/pipelines/processors/transforms/transform_srf.rs b/src/query/service/src/pipelines/processors/transforms/transform_srf.rs
@@ -150,7 +150,7 @@ impl BlockingTransform for TransformSRF {
                 .map(|srf_result| {
                     let (result, rows) = srf_result.get(i).unwrap();
                     if *rows > 0 {
-                        result.memory_size()
+                        result.memory_size(false)
                     } else {
                         0
                     }
diff --git a/src/query/service/src/servers/http/v1/query/sized_spsc.rs b/src/query/service/src/servers/http/v1/query/sized_spsc.rs
@@ -199,7 +199,7 @@ impl PageBuilder {
             .iter()
             .map(|entry| match entry {
                 BlockEntry::Const(scalar, _, n) => *n * scalar.as_ref().memory_size(),
-                BlockEntry::Column(column) => column.memory_size(),
+                BlockEntry::Column(column) => column.memory_size(true),
             })
             .sum::<usize>();
 
diff --git a/src/query/storages/fuse/src/io/read/inverted_index/inverted_index_loader.rs b/src/query/storages/fuse/src/io/read/inverted_index/inverted_index_loader.rs
@@ -264,7 +264,7 @@ pub(crate) async fn load_inverted_index_files<'a>(
                 inverted_binary,
                 &databend_common_expression::types::DataType::Binary,
             )?;
-            inverted_bytes_len += column.memory_size();
+            inverted_bytes_len += column.memory_size(false);
             let value = unsafe { column.index_unchecked(0) };
             let bytes = value.as_binary().unwrap();
             let file = InvertedIndexFile::create(name.clone(), bytes.to_vec());
diff --git a/src/query/storages/fuse/src/io/read/vector_index/vector_index_loader.rs b/src/query/storages/fuse/src/io/read/vector_index/vector_index_loader.rs
diff --git a/src/query/storages/fuse/src/io/write/bloom_index_writer.rs b/src/query/storages/fuse/src/io/write/bloom_index_writer.rs
diff --git a/src/query/storages/fuse/src/io/write/stream/column_statistics_builder.rs b/src/query/storages/fuse/src/io/write/stream/column_statistics_builder.rs
diff --git a/src/query/storages/fuse/src/statistics/column_statistic.rs b/src/query/storages/fuse/src/statistics/column_statistic.rs

Original file line number	Diff line number	Diff line change
`@@ -314,8 +314,12 @@ impl<T: ViewType + ?Sized> BinaryViewColumnGeneric<T> {`
`314`	`314`	`.get_or_init(\|\| self.views.iter().map(\|v\| v.length as usize).sum::<usize>())`
`315`	`315`	`}`
`316`	`316`
`317`		`- pub fn memory_size(&self) -> usize {`
`318`		`- self.total_buffer_len() + self.len() * 16`
	`317`	`+ pub fn memory_size(&self, gc: bool) -> usize {`
	`318`	`+ if gc {`
	`319`	`+ self.total_bytes_len() + self.len() * 16`
	`320`	`+ } else {`
	`321`	`+ self.total_buffer_len() + self.len() * 16`
	`322`	`+ }`
`319`	`323`	`}`
`320`	`324`
`321`	`325`	`fn total_unshared_buffer_len(&self) -> usize {`
Original file line number	Diff line number	Diff line change
`@@ -607,7 +607,8 @@ pub trait AccessType: Debug + Clone + PartialEq + Sized + 'static {`
`607`	`607`	`std::mem::size_of::<Self::Scalar>()`
`608`	`608`	`}`
`609`	`609`
`610`		`- fn column_memory_size(col: &Self::Column) -> usize {`
	`610`	`+ fn column_memory_size(col: &Self::Column, gc: bool) -> usize {`
	`611`	`+ let _ = gc;`
`611`	`612`	`Self::column_len(col) * std::mem::size_of::<Self::Scalar>()`
`612`	`613`	`}`
`613`	`614`
Original file line number	Diff line number	Diff line change
`@@ -83,8 +83,8 @@ impl AccessType for AnyType {`
`83`	`83`	`scalar.memory_size()`
`84`	`84`	`}`
`85`	`85`
`86`		`- fn column_memory_size(col: &Self::Column) -> usize {`
`87`		`- col.memory_size()`
	`86`	`+ fn column_memory_size(col: &Self::Column, gc: bool) -> usize {`
	`87`	`+ col.memory_size(gc)`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`#[inline(always)]`
Original file line number	Diff line number	Diff line change
`@@ -101,11 +101,11 @@ impl<T: AccessType> AccessType for ArrayType<T> {`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`fn scalar_memory_size(scalar: &Self::ScalarRef<'_>) -> usize {`
`104`		`- <T as AccessType>::column_memory_size(scalar)`
	`104`	`+ <T as AccessType>::column_memory_size(scalar, false)`
`105`	`105`	`}`
`106`	`106`
`107`		`- fn column_memory_size(col: &Self::Column) -> usize {`
`108`		`- col.memory_size()`
	`107`	`+ fn column_memory_size(col: &Self::Column, gc: bool) -> usize {`
	`108`	`+ col.memory_size(gc)`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`fn compare(a: T::Column, b: T::Column) -> Ordering {`
`@@ -269,8 +269,8 @@ impl<T: AccessType> ArrayColumn<T> {`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`
`272`		`- pub fn memory_size(&self) -> usize {`
`273`		`- T::column_memory_size(&self.underlying_column()) + self.offsets.len() * 8`
	`272`	`+ pub fn memory_size(&self, gc: bool) -> usize {`
	`273`	`+ T::column_memory_size(&self.underlying_column(), gc) + self.offsets.len() * 8`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`// Note: if the array column has been sliced, the number of values may not match the offsets.`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ impl AccessType for BinaryType {`
`100`	`100`	`scalar.len()`
`101`	`101`	`}`
`102`	`102`
`103`		`- fn column_memory_size(col: &Self::Column) -> usize {`
	`103`	`+ fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {`
`104`	`104`	`col.data().len() + col.offsets().len() * 8`
`105`	`105`	`}`
`106`	`106`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ where`
`111`	`111`	`std::mem::size_of::<F>()`
`112`	`112`	`}`
`113`	`113`
`114`		`- fn column_memory_size(col: &Self::Column) -> usize {`
	`114`	`+ fn column_memory_size(col: &Self::Column, _gc: bool) -> usize {`
`115`	`115`	`F::column_len(col) * std::mem::size_of::<F>()`
`116`	`116`	`}`
`117`	`117`
Original file line number	Diff line number	Diff line change
`@@ -86,8 +86,8 @@ impl<const INDEX: usize> AccessType for GenericType<INDEX> {`
`86`	`86`	`scalar.memory_size()`
`87`	`87`	`}`
`88`	`88`
`89`		`- fn column_memory_size(col: &Self::Column) -> usize {`
`90`		`- col.memory_size()`
	`89`	`+ fn column_memory_size(col: &Self::Column, gc: bool) -> usize {`
	`90`	`+ col.memory_size(gc)`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`#[inline(always)]`