Vector::clear

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-mask/src/lib.rs

@@ -303,6 +303,11 @@ impl Mask {
         Self::from_indices(len, intersection)
     }
 
+    /// Clears the mask of all data. Drops any allocated capacity.
+    pub fn clear(&mut self) {
+        *self = Self::new_false(0);
+    }
+
     /// Returns the length of the mask (not the number of true values).
     #[inline]
     pub fn len(&self) -> usize {

vortex-vector/src/binaryview/vector.rs

@@ -211,6 +211,12 @@ impl<T: BinaryViewType> VectorOps for BinaryViewVector<T> {
         todo!()
     }
 
+    fn clear(&mut self) {
+        self.views.clear();
+        self.validity = Mask::new_true(0);
+        self.buffers = Arc::new(Box::new([]));
+    }
+
     fn try_into_mut(self) -> Result<BinaryViewVectorMut<T>, Self> {
         let views_mut = match self.views.try_into_mut() {
             Ok(views_mut) => views_mut,

vortex-vector/src/bool/vector.rs

@@ -99,6 +99,11 @@ impl VectorOps for BoolVector {
         Self { bits, validity }
     }
 
+    fn clear(&mut self) {
+        self.bits.clear();
+        self.validity.clear();
+    }
+
     fn try_into_mut(self) -> Result<BoolVectorMut, Self> {
         let bits = match self.bits.try_into_mut() {
             Ok(bits) => bits,

vortex-vector/src/decimal/generic.rs

@@ -188,6 +188,11 @@ impl<D: NativeDecimalType> VectorOps for DVector<D> {
         }
     }
 
+    fn clear(&mut self) {
+        self.elements.clear();
+        self.validity.clear();
+    }
+
     fn try_into_mut(self) -> Result<DVectorMut<D>, Self> {
         let elements = match self.elements.try_into_mut() {
             Ok(elements) => elements,

vortex-vector/src/decimal/vector.rs

@@ -73,6 +73,10 @@ impl VectorOps for DecimalVector {
         match_each_dvector!(self, |v| { DecimalVector::from(v.slice(range)) })
     }
 
+    fn clear(&mut self) {
+        match_each_dvector!(self, |v| { v.clear() })
+    }
+
     fn try_into_mut(self) -> Result<DecimalVectorMut, Self> {
         match_each_dvector!(self, |v| {
             v.try_into_mut()

vortex-vector/src/fixed_size_list/vector.rs

@@ -165,6 +165,12 @@ impl VectorOps for FixedSizeListVector {
         todo!()
     }
 
+    fn clear(&mut self) {
+        Arc::make_mut(&mut self.elements).clear();
+        self.validity.clear();
+        self.len = 0;
+    }
+
     fn try_into_mut(self) -> Result<FixedSizeListVectorMut, Self> {
         let len = self.len;
         let list_size = self.list_size;

vortex-vector/src/listview/vector.rs

@@ -220,6 +220,14 @@ impl VectorOps for ListViewVector {
         todo!()
     }
 
+    fn clear(&mut self) {
+        self.offsets.clear();
+        self.sizes.clear();
+        Arc::make_mut(&mut self.elements).clear();
+        self.validity.clear();
+        self.len = 0;
+    }
+
     fn try_into_mut(self) -> Result<ListViewVectorMut, Self> {
         // Try to unwrap the `Arc`.
         let elements = match Arc::try_unwrap(self.elements) {

vortex-vector/src/null/vector.rs

@@ -57,6 +57,11 @@ impl VectorOps for NullVector {
         Self::new(len)
     }
 
+    fn clear(&mut self) {
+        self.len = 0;
+        self.validity = Mask::AllFalse(0);
+    }
+
     fn try_into_mut(self) -> Result<NullVectorMut, Self> {
         Ok(NullVectorMut::new(self.len))
     }

vortex-vector/src/primitive/generic.rs

@@ -142,6 +142,11 @@ impl<T: NativePType> VectorOps for PVector<T> {
         Self::new(elements, validity)
     }
 
+    fn clear(&mut self) {
+        self.elements.clear();
+        self.validity.clear();
+    }
+
     /// Try to convert self into a mutable vector.
     fn try_into_mut(self) -> Result<PVectorMut<T>, Self> {
         let elements = match self.elements.try_into_mut() {

vortex-vector/src/primitive/vector.rs

@@ -86,6 +86,10 @@ impl VectorOps for PrimitiveVector {
         match_each_pvector!(self, |v| { v.slice(range).into() })
     }
 
+    fn clear(&mut self) {
+        match_each_pvector!(self, |v| { v.clear() })
+    }
+
     fn try_into_mut(self) -> Result<PrimitiveVectorMut, Self> {
         match_each_pvector!(self, |v| {
             v.try_into_mut()