set up scaffolding for FixedSizeListVector

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

Author: connortsui20

vortex-compute/src/mask/mod.rs

@@ -8,8 +8,9 @@ use std::ops::BitAnd;
 use vortex_dtype::{NativeDecimalType, NativePType};
 use vortex_mask::Mask;
 use vortex_vector::{
-    BoolVector, DVector, DecimalVector, NullVector, PVector, PrimitiveVector, StructVector,
-    VarBinType, VarBinVector, Vector, match_each_dvector, match_each_pvector, match_each_vector,
+    BoolVector, DVector, DecimalVector, FixedSizeListVector, NullVector, PVector, PrimitiveVector,
+    StructVector, VarBinType, VarBinVector, Vector, match_each_dvector, match_each_pvector,
+    match_each_vector,
 };
 
 /// Trait for masking the validity of an array or vector.
@@ -78,6 +79,12 @@ impl<T: VarBinType> MaskValidity for VarBinVector<T> {
     }
 }
 
+impl MaskValidity for FixedSizeListVector {
+    fn mask_validity(self, _mask: &Mask) -> Self {
+        todo!()
+    }
+}
+
 impl MaskValidity for StructVector {
     fn mask_validity(self, mask: &Mask) -> Self {
         let (fields, validity) = self.into_parts();

vortex-vector/src/fixed_size_list/mod.rs

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

vortex-vector/src/fixed_size_list/vector.rs

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition and implementation of [`FixedSizeListVector`].
+
+use crate::{FixedSizeListVectorMut, VectorOps};
+
+/// An immutable vector of fixed-size lists.
+///
+/// `FixedSizeListVector` can be considered a borrowed / frozen version of
+/// [`FixedSizeListVectorMut`], which is created via the [`freeze`](crate::VectorMutOps::freeze)
+/// method.
+///
+/// See the documentation for [`FixedSizeListVectorMut`] for more information.
+#[derive(Debug, Clone)]
+pub struct FixedSizeListVector;
+
+impl VectorOps for FixedSizeListVector {
+    type Mutable = FixedSizeListVectorMut;
+
+    fn len(&self) -> usize {
+        todo!()
+    }
+
+    fn validity(&self) -> &vortex_mask::Mask {
+        todo!()
+    }
+
+    fn try_into_mut(self) -> Result<Self::Mutable, Self>
+    where
+        Self: Sized,
+    {
+        todo!()
+    }
+}

vortex-vector/src/fixed_size_list/vector_mut.rs

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition and implementation of [`FixedSizeListVectorMut`].
+
+use crate::{FixedSizeListVector, VectorMutOps};
+
+/// TODO docs.
+#[derive(Debug, Clone)]
+pub struct FixedSizeListVectorMut;
+
+impl VectorMutOps for FixedSizeListVectorMut {
+    type Immutable = FixedSizeListVector;
+
+    fn len(&self) -> usize {
+        todo!()
+    }
+
+    fn capacity(&self) -> usize {
+        todo!()
+    }
+
+    fn reserve(&mut self, _additional: usize) {
+        todo!()
+    }
+
+    fn extend_from_vector(&mut self, _other: &Self::Immutable) {
+        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/lib.rs

@@ -12,13 +12,15 @@
 
 mod bool;
 mod decimal;
+mod fixed_size_list;
 mod null;
 mod primitive;
 mod struct_;
 mod varbin;
 
 pub use bool::*;
 pub use decimal::*;
+pub use fixed_size_list::*;
 pub use null::*;
 pub use primitive::*;
 pub use struct_::*;

vortex-vector/src/macros.rs

@@ -45,6 +45,7 @@ macro_rules! match_each_vector {
             $crate::Vector::Primitive($vec) => $body,
             $crate::Vector::String($vec) => $body,
             $crate::Vector::Binary($vec) => $body,
+            $crate::Vector::FixedSizeList($vec) => $body,
             $crate::Vector::Struct($vec) => $body,
         }
     }};
@@ -91,6 +92,7 @@ macro_rules! match_each_vector_mut {
             $crate::VectorMut::Primitive($vec) => $body,
             $crate::VectorMut::String($vec) => $body,
             $crate::VectorMut::Binary($vec) => $body,
+            $crate::VectorMut::FixedSizeList($vec) => $body,
             $crate::VectorMut::Struct($vec) => $body,
         }
     }};
@@ -115,6 +117,9 @@ macro_rules! __match_vector_pair_arms {
             ($crate::$enum_left::Primitive($a), $crate::$enum_right::Primitive($b)) => $body,
             ($crate::$enum_left::String($a), $crate::$enum_right::String($b)) => $body,
             ($crate::$enum_left::Binary($a), $crate::$enum_right::Binary($b)) => $body,
+            ($crate::$enum_left::FixedSizeList($a), $crate::$enum_right::FixedSizeList($b)) => {
+                $body
+            }
             ($crate::$enum_left::Struct($a), $crate::$enum_right::Struct($b)) => $body,
             _ => ::vortex_error::vortex_panic!("Mismatched vector types"),
         }

vortex-vector/src/private.rs

@@ -37,5 +37,8 @@ impl<T: NativePType> Sealed for PVectorMut<T> {}
 impl<T: VarBinType> Sealed for VarBinVector<T> {}
 impl<T: VarBinType> Sealed for VarBinVectorMut<T> {}
 
+impl Sealed for FixedSizeListVector {}
+impl Sealed for FixedSizeListVectorMut {}
+
 impl Sealed for StructVector {}
 impl Sealed for StructVectorMut {}

vortex-vector/src/varbin/types.rs

@@ -85,7 +85,7 @@ pub trait VarBinTypeUpcast {
 
 /// Private module to seal the [`VarBinType`] trait.
 mod private {
-    /// Sealed trait to prevent external implementations of [`VarBinType`].
+    /// Sealed trait to prevent external implementations of [`VarBinType`](super::VarBinType).
     pub trait Sealed {}
 
     impl Sealed for super::StringType {}

vortex-vector/src/vector.rs

@@ -8,6 +8,7 @@
 
 use vortex_error::vortex_panic;
 
+use crate::fixed_size_list::FixedSizeListVector;
 use crate::{
     BinaryVector, BoolVector, DecimalVector, NullVector, PrimitiveVector, StringVector,
     StructVector, VectorMut, VectorOps, match_each_vector,
@@ -41,8 +42,8 @@ pub enum Vector {
     Binary(BinaryVector),
     // List
     // List(ListVector),
-    // FixedList
-    // FixedList(FixedListVector),
+    /// Vectors of Lists with fixed sizes.
+    FixedSizeList(FixedSizeListVector),
     /// Vectors of Struct elements.
     Struct(StructVector),
 }
@@ -109,6 +110,14 @@ impl Vector {
         vortex_panic!("Expected BinaryVector, got {self:?}");
     }
 
+    /// Returns a reference to the inner [`FixedSizeListVector`] if `self` is of that variant.
+    pub fn as_fixed_size_list(&self) -> &FixedSizeListVector {
+        if let Vector::FixedSizeList(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected FixedSizeListVector, 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 {
@@ -159,6 +168,15 @@ impl Vector {
         vortex_panic!("Expected BinaryVector, got {self:?}");
     }
 
+    /// Consumes `self` and returns the inner [`FixedSizeListVector`] if `self` is of that
+    /// variant.
+    pub fn into_fixed_size_list(self) -> FixedSizeListVector {
+        if let Vector::FixedSizeList(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected FixedSizeListVector, 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 {

vortex-vector/src/vector_mut.rs

@@ -9,6 +9,7 @@
 use vortex_dtype::DType;
 use vortex_error::vortex_panic;
 
+use crate::fixed_size_list::FixedSizeListVectorMut;
 use crate::varbin::{BinaryVectorMut, StringVectorMut};
 use crate::{
     BoolVectorMut, DecimalVectorMut, NullVectorMut, PrimitiveVectorMut, StructVectorMut, Vector,
@@ -41,6 +42,8 @@ pub enum VectorMut {
     String(StringVectorMut),
     /// Mutable Binary vectors.
     Binary(BinaryVectorMut),
+    /// Mutable vectors of Lists with fixed sizes.
+    FixedSizeList(FixedSizeListVectorMut),
     /// Mutable vectors of Struct elements.
     Struct(StructVectorMut),
 }
@@ -54,6 +57,7 @@ impl VectorMut {
             DType::Primitive(ptype, _) => {
                 PrimitiveVectorMut::with_capacity(*ptype, capacity).into()
             }
+            DType::FixedSizeList(..) => todo!("TODO(connor)"),
             DType::Struct(struct_fields, _) => {
                 StructVectorMut::with_capacity(struct_fields, capacity).into()
             }
@@ -146,6 +150,14 @@ impl VectorMut {
         vortex_panic!("Expected BinaryVectorMut, got {self:?}");
     }
 
+    /// Returns a reference to the inner [`FixedSizeListVectorMut`] if `self` is of that variant.
+    pub fn as_fixed_size_list(&self) -> &FixedSizeListVectorMut {
+        if let VectorMut::FixedSizeList(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected FixedSizeListVectorMut, 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 {
@@ -196,6 +208,15 @@ impl VectorMut {
         vortex_panic!("Expected BinaryVectorMut, got {self:?}");
     }
 
+    /// Consumes `self` and returns the inner [`FixedSizeListVectorMut`] if `self` is of that
+    /// variant.
+    pub fn into_fixed_size_list(self) -> FixedSizeListVectorMut {
+        if let VectorMut::FixedSizeList(v) = self {
+            return v;
+        }
+        vortex_panic!("Expected FixedSizeListVectorMut, 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 {