add StructVector stubs

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-vector/src/lib.rs

@@ -12,17 +12,22 @@
 #![deny(clippy::missing_safety_doc)]
 
 mod bool;
-mod macros;
 mod null;
-mod ops;
 mod primitive;
-mod private;
-mod vector;
-mod vector_mut;
+mod struct_;
 
 pub use bool::{BoolVector, BoolVectorMut};
 pub use null::{NullVector, NullVectorMut};
-pub use ops::{VectorMutOps, VectorOps};
 pub use primitive::{PVec, PVecMut, PrimitiveVector, PrimitiveVectorMut};
+pub use struct_::{StructVector, StructVectorMut};
+
+mod ops;
+mod vector;
+mod vector_mut;
+
+pub use ops::{VectorMutOps, VectorOps};
 pub use vector::Vector;
 pub use vector_mut::VectorMut;
+
+mod macros;
+mod private;

vortex-vector/src/macros.rs

@@ -48,6 +48,10 @@ macro_rules! match_each_vector {
                 let $vec = v;
                 $body
             }
+            $crate::Vector::Struct(v) => {
+                let $vec = v;
+                $body
+            }
         }
     }};
 }
@@ -98,6 +102,10 @@ macro_rules! match_each_vector_mut {
                 let $vec = v;
                 $body
             }
+            $crate::VectorMut::Struct(v) => {
+                let $vec = v;
+                $body
+            }
         }
     }};
 }

vortex-vector/src/private.rs

@@ -28,3 +28,6 @@ impl Sealed for PrimitiveVector {}
 impl Sealed for PrimitiveVectorMut {}
 impl<T: NativePType> Sealed for PVec<T> {}
 impl<T: NativePType> Sealed for PVecMut<T> {}
+
+impl Sealed for StructVector {}
+impl Sealed for StructVectorMut {}

vortex-vector/src/struct_/mod.rs

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition and implementation of [`StructVector`] and [`StructVectorMut`].
+
+mod vector;
+pub use vector::StructVector;
+
+mod vector_mut;
+pub use vector_mut::StructVectorMut;
+
+use crate::{Vector, VectorMut};
+
+impl From<StructVector> for Vector {
+    fn from(v: StructVector) -> Self {
+        Self::Struct(v)
+    }
+}
+
+impl From<StructVectorMut> for VectorMut {
+    fn from(v: StructVectorMut) -> Self {
+        Self::Struct(v)
+    }
+}

vortex-vector/src/struct_/vector.rs

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition and implementation of [`StructVector`].
+
+use vortex_mask::Mask;
+
+use crate::{StructVectorMut, VectorOps};
+
+/// An immutable vector of boolean values.
+///
+/// `StructVector` can be considered a borrowed / frozen version of [`StructVectorMut`], which is
+/// created via the [`freeze`](crate::VectorMutOps::freeze) method.
+///
+/// See the documentation for [`StructVectorMut`] for more information.
+#[derive(Debug, Clone)]
+pub struct StructVector {
+    /// The validity mask (where `true` represents an element is **not** null).
+    pub(super) validity: Mask,
+}
+
+impl VectorOps for StructVector {
+    type Mutable = StructVectorMut;
+
+    fn len(&self) -> usize {
+        todo!()
+    }
+
+    fn validity(&self) -> &Mask {
+        &self.validity
+    }
+
+    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    where
+        Self: Sized,
+    {
+        todo!()
+    }
+}

vortex-vector/src/struct_/vector_mut.rs

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition and implementation of [`StructVectorMut`].
+
+use vortex_mask::MaskMut;
+
+use crate::{StructVector, VectorMutOps};
+
+/// A mutable vector of struct values (values with named fields).
+///
+/// TODO docs.
+#[derive(Debug, Clone)]
+pub struct StructVectorMut {
+    /// The validity mask (where `true` represents an element is **not** null).
+    pub(super) _validity: MaskMut,
+}
+
+impl StructVectorMut {
+    /// Creates a new mutable boolean vector with the given `capacity`.
+    pub fn with_capacity(_capacity: usize) -> Self {
+        todo!()
+    }
+}
+
+impl VectorMutOps for StructVectorMut {
+    type Immutable = StructVector;
+
+    fn len(&self) -> usize {
+        todo!()
+    }
+
+    fn capacity(&self) -> usize {
+        todo!()
+    }
+
+    fn reserve(&mut self, _additional: usize) {
+        todo!()
+    }
+
+    fn extend_from_vector(&mut self, _other: &StructVector) {
+        todo!()
+    }
+
+    fn append_nulls(&mut self, _n: usize) {
+        todo!()
+    }
+
+    fn freeze(self) -> Self::Immutable {
+        todo!()
+    }
+
+    fn split_off(&mut self, _at: usize) -> Self {
+        todo!()
+    }
+
+    fn unsplit(&mut self, _other: Self) {
+        todo!()
+    }
+}

vortex-vector/src/vector.rs

@@ -9,7 +9,7 @@
 use vortex_error::vortex_panic;
 
 use crate::macros::match_each_vector;
-use crate::{BoolVector, NullVector, PrimitiveVector, VectorMut, VectorOps};
+use crate::{BoolVector, NullVector, PrimitiveVector, StructVector, VectorMut, VectorOps};
 
 /// An enum over all kinds of immutable vectors, which represent fully decompressed (canonical)
 /// array data.
@@ -41,8 +41,8 @@ pub enum Vector {
     // List(ListVector),
     // FixedList
     // FixedList(FixedListVector),
-    // Struct
-    // Struct(StructVector),
+    /// Vectors of Struct elements.
+    Struct(StructVector),
     // Extension
     // Extension(ExtensionVector),
 }
@@ -69,27 +69,67 @@ impl VectorOps for Vector {
 }
 
 impl Vector {
-    /// Consumes `self` and returns the inner `NullVector` if `self` is of that variant.
+    /// Returns a reference to the inner [`NullVector`] if `self` is of that variant.
+    pub fn as_null(&self) -> &NullVector {
+        if let Vector::Null(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected NullVector, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`BoolVector`] if `self` is of that variant.
+    pub fn as_bool(&self) -> &BoolVector {
+        if let Vector::Bool(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected BoolVector, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`PrimitiveVector`] if `self` is of that variant.
+    pub fn as_primitive(&self) -> &PrimitiveVector {
+        if let Vector::Primitive(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected PrimitiveVector, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`StructVector`] if `self` is of that variant.
+    pub fn as_struct(&self) -> &StructVector {
+        if let Vector::Struct(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected StructVector, got {self:?}");
+    }
+
+    /// Consumes `self` and returns the inner [`NullVector`] if `self` is of that variant.
     pub fn into_null(self) -> NullVector {
         if let Vector::Null(v) = self {
             return v;
         }
         vortex_panic!("Expected NullVector, got {self:?}");
     }
 
-    /// Consumes `self` and returns the inner `BoolVector` if `self` is of that variant.
+    /// Consumes `self` and returns the inner [`BoolVector`] if `self` is of that variant.
     pub fn into_bool(self) -> BoolVector {
         if let Vector::Bool(v) = self {
             return v;
         }
         vortex_panic!("Expected BoolVector, got {self:?}");
     }
 
-    /// Consumes `self` and returns the inner `PrimitiveVector` if `self` is of that variant.
+    /// Consumes `self` and returns the inner [`PrimitiveVector`] if `self` is of that variant.
     pub fn into_primitive(self) -> PrimitiveVector {
         if let Vector::Primitive(v) = self {
             return v;
         }
         vortex_panic!("Expected PrimitiveVector, got {self:?}");
     }
+
+    /// Consumes `self` and returns the inner [`StructVector`] if `self` is of that variant.
+    pub fn into_struct(self) -> StructVector {
+        if let Vector::Struct(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected StructVector, got {self:?}");
+    }
 }

vortex-vector/src/vector_mut.rs

@@ -10,7 +10,9 @@ use vortex_dtype::DType;
 use vortex_error::vortex_panic;
 
 use super::macros::match_each_vector_mut;
-use crate::{BoolVectorMut, NullVectorMut, PrimitiveVectorMut, Vector, VectorMutOps};
+use crate::{
+    BoolVectorMut, NullVectorMut, PrimitiveVectorMut, StructVectorMut, Vector, VectorMutOps,
+};
 
 /// An enum over all kinds of mutable vectors, which represent fully decompressed (canonical) array
 /// data.
@@ -23,15 +25,17 @@ use crate::{BoolVectorMut, NullVectorMut, PrimitiveVectorMut, Vector, VectorMutO
 /// [`VectorOps`](crate::VectorOps) trait.
 #[derive(Debug, Clone)]
 pub enum VectorMut {
-    /// Null mutable vectors.
+    /// Mutable Null vectors.
     Null(NullVectorMut),
-    /// Boolean mutable vectors.
+    /// Mutable Boolean vectors.
     Bool(BoolVectorMut),
-    /// Primitive mutable vectors.
+    /// Mutable Primitive vectors.
     ///
     /// Note that [`PrimitiveVectorMut`] is an enum over the different possible (generic)
     /// [`PVecMut<T>`](crate::PVecMut)s. See the documentation for more information.
     Primitive(PrimitiveVectorMut),
+    /// Mutable vectors of Struct elements.
+    Struct(StructVectorMut),
 }
 
 impl VectorMut {
@@ -95,29 +99,69 @@ impl VectorMutOps for VectorMut {
 }
 
 impl VectorMut {
-    /// Convert into NullVectorMut, panicking if the type does not match.
+    /// Returns a reference to the inner [`NullVectorMut`] if `self` is of that variant.
+    pub fn as_null(&self) -> &NullVectorMut {
+        if let VectorMut::Null(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected NullVectorMut, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`BoolVectorMut`] if `self` is of that variant.
+    pub fn as_bool(&self) -> &BoolVectorMut {
+        if let VectorMut::Bool(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected BoolVectorMut, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`PrimitiveVectorMut`] if `self` is of that variant.
+    pub fn as_primitive(&self) -> &PrimitiveVectorMut {
+        if let VectorMut::Primitive(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected PrimitiveVectorMut, got {self:?}");
+    }
+
+    /// Returns a reference to the inner [`StructVectorMut`] if `self` is of that variant.
+    pub fn as_struct(&self) -> &StructVectorMut {
+        if let VectorMut::Struct(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected StructVectorMut, got {self:?}");
+    }
+
+    /// Consumes `self` and returns the inner [`NullVectorMut`] if `self` is of that variant.
     pub fn into_null(self) -> NullVectorMut {
         if let VectorMut::Null(v) = self {
             return v;
         }
         vortex_panic!("Expected NullVectorMut, got {self:?}");
     }
 
-    /// Convert into BoolVectorMut, panicking if the type does not match.
+    /// Consumes `self` and returns the inner [`BoolVectorMut`] if `self` is of that variant.
     pub fn into_bool(self) -> BoolVectorMut {
         if let VectorMut::Bool(v) = self {
             return v;
         }
         vortex_panic!("Expected BoolVectorMut, got {self:?}");
     }
 
-    /// Convert into PrimitiveVectorMut, panicking if the type does not match.
+    /// Consumes `self` and returns the inner [`PrimitiveVectorMut`] if `self` is of that variant.
     pub fn into_primitive(self) -> PrimitiveVectorMut {
         if let VectorMut::Primitive(v) = self {
             return v;
         }
         vortex_panic!("Expected PrimitiveVectorMut, got {self:?}");
     }
+
+    /// Consumes `self` and returns the inner [`StructVectorMut`] if `self` is of that variant.
+    pub fn into_struct(self) -> StructVectorMut {
+        if let VectorMut::Struct(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected StructVectorMut, got {self:?}");
+    }
 }
 
 #[cfg(test)]