fix: Builder ensure_capacity is now reserve_exact to acquire additional and not total capacity

vortex-array/src/arrays/list/compute/take.rs

@@ -82,7 +82,7 @@ fn _take<I: IntegerPType, O: IntegerPType>(
             vortex_panic!("Failed to convert range length to usize: {}", stop - start)
         });
 
-        elements_to_take.ensure_capacity(elements_to_take.len() + additional);
+        elements_to_take.reserve_exact(additional);
         for i in 0..additional {
             elements_to_take.append_value(start + O::from_usize(i).vortex_expect("i < additional"));
         }
@@ -150,7 +150,7 @@ fn _take_nullable<I: IntegerPType, O: IntegerPType>(
                 vortex_panic!("Failed to convert range length to usize: {}", stop - start)
             });
 
-            elements_to_take.ensure_capacity(elements_to_take.len() + additional);
+            elements_to_take.reserve_exact(additional);
             for i in 0..additional {
                 elements_to_take
                     .append_value(start + O::from_usize(i).vortex_expect("i < additional"));

vortex-array/src/builders/bool.rs

@@ -111,11 +111,9 @@ impl ArrayBuilder for BoolBuilder {
         self.nulls.append_validity_mask(bool_array.validity_mask());
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        if capacity > self.inner.capacity() {
-            self.inner.reserve(capacity - self.inner.capacity());
-            self.nulls.ensure_capacity(capacity);
-        }
+    fn reserve_exact(&mut self, additional: usize) {
+        self.inner.reserve(additional);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/decimal.rs

@@ -191,11 +191,9 @@ impl ArrayBuilder for DecimalBuilder {
             .append_validity_mask(decimal_array.validity_mask());
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        if capacity > self.values.capacity() {
-            self.values.reserve(capacity - self.values.len());
-            self.nulls.ensure_capacity(capacity);
-        }
+    fn reserve_exact(&mut self, additional: usize) {
+        self.values.reserve(additional);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
@@ -232,10 +230,6 @@ impl DecimalBuffer {
         delegate_fn!(self, |T, buffer| { buffer.reserve(additional) })
     }
 
-    fn capacity(&self) -> usize {
-        delegate_fn!(self, |T, buffer| { buffer.capacity() })
-    }
-
     fn len(&self) -> usize {
         delegate_fn!(self, |T, buffer| { buffer.len() })
     }

vortex-array/src/builders/extension.rs

@@ -97,8 +97,8 @@ impl ArrayBuilder for ExtensionBuilder {
         self.storage.extend_from_array(ext_array.storage())
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        self.storage.ensure_capacity(capacity)
+    fn reserve_exact(&mut self, capacity: usize) {
+        self.storage.reserve_exact(capacity)
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/fixed_size_list.rs

@@ -139,11 +139,6 @@ impl FixedSizeListBuilder {
 
         list_size
     }
-
-    /// Returns the current length of underlying `elements` array.
-    fn elements_len(&self) -> usize {
-        self.len() * self.list_size() as usize
-    }
 }
 
 impl ArrayBuilder for FixedSizeListBuilder {
@@ -208,19 +203,14 @@ impl ArrayBuilder for FixedSizeListBuilder {
             return;
         }
 
-        let new_elements = fsl.elements();
-
-        self.elements_builder
-            .ensure_capacity(self.elements_len() + new_elements.len());
-        self.elements_builder.extend_from_array(new_elements);
-
+        self.elements_builder.extend_from_array(fsl.elements());
         self.nulls.append_validity_mask(array.validity_mask());
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
+    fn reserve_exact(&mut self, additional: usize) {
         self.elements_builder
-            .ensure_capacity(capacity * self.list_size() as usize);
-        self.nulls.ensure_capacity(capacity);
+            .reserve_exact(additional * self.list_size() as usize);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/lazy_null_builder.rs

@@ -119,18 +119,15 @@ impl LazyNullBufferBuilder {
         }
     }
 
-    /// Ensures the builder has at least the specified capacity.
-    pub fn ensure_capacity(&mut self, capacity: usize) {
+    /// Ensures the builder can hold `additional` extra values.
+    pub fn reserve_exact(&mut self, additional: usize) {
         if self.inner.is_none() {
-            self.capacity = capacity;
+            self.capacity += additional;
         } else {
-            let inner = self
-                .inner
+            self.inner
                 .as_mut()
-                .vortex_expect("buffer just materialized");
-            if capacity < inner.capacity() {
-                inner.reserve(capacity - inner.len());
-            }
+                .vortex_expect("buffer just materialized")
+                .reserve(additional);
         }
     }
 

vortex-array/src/builders/list.rs

@@ -228,15 +228,14 @@ impl<O: IntegerPType> ArrayBuilder for ListBuilder<O> {
         let non_junk_values = elements.slice(n_leading_junk_values_usize..last_offset_usize);
 
         self.nulls.append_validity_mask(array.validity_mask());
-        self.elements_builder
-            .ensure_capacity(self.elements_builder.len() + non_junk_values.len());
+        self.elements_builder.reserve_exact(non_junk_values.len());
         self.elements_builder.extend_from_array(&non_junk_values);
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        self.elements_builder.ensure_capacity(capacity);
-        self.offsets_builder.ensure_capacity(capacity);
-        self.nulls.ensure_capacity(capacity);
+    fn reserve_exact(&mut self, additional: usize) {
+        self.elements_builder.reserve_exact(additional);
+        self.offsets_builder.reserve_exact(additional);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/listview.rs

@@ -252,11 +252,11 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
         }
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        self.elements_builder.ensure_capacity(capacity * 2);
-        self.offsets_builder.ensure_capacity(capacity);
-        self.sizes_builder.ensure_capacity(capacity);
-        self.nulls.ensure_capacity(capacity);
+    fn reserve_exact(&mut self, capacity: usize) {
+        self.elements_builder.reserve_exact(capacity * 2);
+        self.offsets_builder.reserve_exact(capacity);
+        self.sizes_builder.reserve_exact(capacity);
+        self.nulls.reserve_exact(capacity);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/mod.rs

@@ -170,8 +170,8 @@ pub trait ArrayBuilder: Send {
         unsafe { self.extend_from_array_unchecked(array) }
     }
 
-    /// Ensure that the builder can hold at least `capacity` number of items
-    fn ensure_capacity(&mut self, capacity: usize);
+    /// Allocate space for extra `additional` items
+    fn reserve_exact(&mut self, additional: usize);
 
     /// Override builders validity with the one provided.
     ///

vortex-array/src/builders/null.rs

@@ -71,7 +71,7 @@ impl ArrayBuilder for NullBuilder {
         self.append_nulls(array.len());
     }
 
-    fn ensure_capacity(&mut self, _capacity: usize) {}
+    fn reserve_exact(&mut self, _additional: usize) {}
 
     unsafe fn set_validity_unchecked(&mut self, _validity: Mask) {}
 

vortex-array/src/builders/primitive.rs

@@ -87,7 +87,8 @@ impl<T: NativePType> PrimitiveBuilder<T> {
         let current_len = self.values.len();
         assert!(
             current_len + len <= self.values.capacity(),
-            "uninit_range of len {len} exceeds builder capacity {}",
+            "uninit_range of len {len} exceeds builder with length {} and capacity {}",
+            current_len,
             self.values.capacity()
         );
 
@@ -168,11 +169,9 @@ impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
         self.nulls.append_validity_mask(array.validity_mask());
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        if capacity > self.values.capacity() {
-            self.values.reserve(capacity - self.values.len());
-            self.nulls.ensure_capacity(capacity);
-        }
+    fn reserve_exact(&mut self, additional: usize) {
+        self.values.reserve(additional);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
@@ -512,7 +511,9 @@ mod tests {
 
     /// Test that creating an uninit range exceeding capacity panics.
     #[test]
-    #[should_panic(expected = "uninit_range of len 10 exceeds builder capacity")]
+    #[should_panic(
+        expected = "uninit_range of len 10 exceeds builder with length 0 and capacity 6"
+    )]
     fn test_uninit_range_exceeds_capacity_panics() {
         let mut builder = PrimitiveBuilder::<i32>::with_capacity(Nullability::NonNullable, 5);
         let _range = builder.uninit_range(10);

vortex-array/src/builders/struct_.rs

@@ -170,11 +170,11 @@ impl ArrayBuilder for StructBuilder {
         self.nulls.append_validity_mask(array.validity_mask());
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
+    fn reserve_exact(&mut self, capacity: usize) {
         self.builders.iter_mut().for_each(|builder| {
-            builder.ensure_capacity(capacity);
+            builder.reserve_exact(capacity);
         });
-        self.nulls.ensure_capacity(capacity);
+        self.nulls.reserve_exact(capacity);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {

vortex-array/src/builders/varbinview.rs

@@ -300,12 +300,9 @@ impl ArrayBuilder for VarBinViewBuilder {
         }
     }
 
-    fn ensure_capacity(&mut self, capacity: usize) {
-        if capacity > self.views_builder.capacity() {
-            self.views_builder
-                .reserve(capacity - self.views_builder.len());
-            self.nulls.ensure_capacity(capacity);
-        }
+    fn reserve_exact(&mut self, additional: usize) {
+        self.views_builder.reserve(additional);
+        self.nulls.reserve_exact(additional);
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {