fix imports

Signed-off-by: Connor Tsui <[email protected]>

Author: connortsui20

vortex-vector/src/primitive/macros.rs

@@ -92,8 +92,6 @@ macro_rules! match_each_pvector {
     }};
 }
 
-pub(crate) use match_each_pvector;
-
 /// Matches on all primitive type variants of [`PrimitiveVectorMut`] and executes the same code
 /// for each variant branch.
 ///
@@ -176,5 +174,3 @@ macro_rules! match_each_pvector_mut {
         }
     }};
 }
-
-pub(crate) use match_each_pvector_mut;

vortex-vector/src/primitive/vector.rs

@@ -7,8 +7,7 @@ use vortex_dtype::half::f16;
 use vortex_dtype::{NativePType, PType, PTypeDowncast, PTypeUpcast};
 use vortex_error::vortex_panic;
 
-use super::macros::match_each_pvector;
-use crate::{PVector, PrimitiveVectorMut, VectorOps};
+use crate::{PVector, PrimitiveVectorMut, VectorOps, match_each_pvector};
 
 /// An immutable vector of primitive values.
 ///

vortex-vector/src/primitive/vector_mut.rs

@@ -7,8 +7,7 @@ use vortex_dtype::half::f16;
 use vortex_dtype::{NativePType, PType, PTypeDowncast, PTypeUpcast};
 use vortex_error::vortex_panic;
 
-use super::macros::match_each_pvector_mut;
-use crate::{PVectorMut, PrimitiveVector, VectorMutOps};
+use crate::{PVectorMut, PrimitiveVector, VectorMutOps, match_each_pvector_mut};
 
 /// A mutable vector of primitive values.
 ///

vortex-vector/src/struct_/vector.rs

@@ -33,8 +33,7 @@ pub struct StructVector {
 
     /// The length of the vector (which is the same as all field vectors).
     ///
-    /// This is stored here as a convenience, and also helps in the case that the `StructVector` has
-    /// no fields.
+    /// This is stored here as a convenience, as the validity also tracks this information.
     pub(super) len: usize,
 }
 
@@ -111,14 +110,14 @@ impl StructVector {
         }
     }
 
-    /// Decomposes the struct vector into its constituent parts (fields, validity, and length).
+    /// Decomposes the struct vector into its constituent parts (fields and validity).
     pub fn into_parts(self) -> (Arc<Box<[Vector]>>, Mask) {
         (self.fields, self.validity)
     }
 
     /// Returns the fields of the `StructVector`, each stored column-wise as a [`Vector`].
-    pub fn fields(&self) -> &[Vector] {
-        self.fields.as_ref()
+    pub fn fields(&self) -> &Arc<Box<[Vector]>> {
+        &self.fields
     }
 }
 

vortex-vector/src/struct_/vector_mut.rs

@@ -237,12 +237,14 @@ impl VectorMutOps for StructVectorMut {
         );
 
         // Extend each field vector.
-        let pairs = self.fields.iter_mut().zip(other.fields());
+        let pairs = self.fields.iter_mut().zip(other.fields().as_ref());
         for (self_mut_vector, other_vec) in pairs {
             match (self_mut_vector, other_vec) {
                 (VectorMut::Null(a), Vector::Null(b)) => a.extend_from_vector(b),
                 (VectorMut::Bool(a), Vector::Bool(b)) => a.extend_from_vector(b),
                 (VectorMut::Primitive(a), Vector::Primitive(b)) => a.extend_from_vector(b),
+                (VectorMut::String(a), Vector::String(b)) => a.extend_from_vector(b),
+                (VectorMut::Binary(a), Vector::Binary(b)) => a.extend_from_vector(b),
                 (VectorMut::Struct(a), Vector::Struct(b)) => a.extend_from_vector(b),
                 _ => {
                     vortex_panic!("Mismatched field types in `StructVectorMut::extend_from_vector`")
@@ -324,6 +326,8 @@ impl VectorMutOps for StructVectorMut {
                 (VectorMut::Null(a), VectorMut::Null(b)) => a.unsplit(b),
                 (VectorMut::Bool(a), VectorMut::Bool(b)) => a.unsplit(b),
                 (VectorMut::Primitive(a), VectorMut::Primitive(b)) => a.unsplit(b),
+                (VectorMut::String(a), VectorMut::String(b)) => a.unsplit(b),
+                (VectorMut::Binary(a), VectorMut::Binary(b)) => a.unsplit(b),
                 (VectorMut::Struct(a), VectorMut::Struct(b)) => a.unsplit(b),
                 _ => {
                     vortex_panic!("Mismatched field types in `StructVectorMut::unsplit`")

vortex-vector/src/vector.rs

@@ -8,9 +8,10 @@
 
 use vortex_error::vortex_panic;
 
-use crate::macros::match_each_vector;
 use crate::varbin::{BinaryVector, StringVector};
-use crate::{BoolVector, NullVector, PrimitiveVector, StructVector, VectorMut, VectorOps};
+use crate::{
+    BoolVector, NullVector, PrimitiveVector, StructVector, VectorMut, VectorOps, match_each_vector,
+};
 
 /// An enum over all kinds of immutable vectors, which represent fully decompressed (canonical)
 /// array data.

vortex-vector/src/vector_mut.rs

@@ -10,10 +10,10 @@ use vortex_dtype::DType;
 use vortex_error::vortex_panic;
 use vortex_mask::MaskMut;
 
-use super::macros::match_each_vector_mut;
 use crate::varbin::{BinaryVectorMut, StringVectorMut};
 use crate::{
     BoolVectorMut, NullVectorMut, PrimitiveVectorMut, StructVectorMut, Vector, VectorMutOps,
+    match_each_vector_mut,
 };
 
 /// An enum over all kinds of mutable vectors, which represent fully decompressed (canonical) array
@@ -98,6 +98,8 @@ impl VectorMutOps for VectorMut {
             (VectorMut::Null(a), Vector::Null(b)) => a.extend_from_vector(b),
             (VectorMut::Bool(a), Vector::Bool(b)) => a.extend_from_vector(b),
             (VectorMut::Primitive(a), Vector::Primitive(b)) => a.extend_from_vector(b),
+            (VectorMut::String(a), Vector::String(b)) => a.extend_from_vector(b),
+            (VectorMut::Binary(a), Vector::Binary(b)) => a.extend_from_vector(b),
             (VectorMut::Struct(a), Vector::Struct(b)) => a.extend_from_vector(b),
             _ => vortex_panic!("Mismatched vector types"),
         }