wip

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

vortex-vector/src/bool/vector.rs

@@ -189,3 +189,52 @@ impl VectorOps for BoolVector {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::BitBuffer;
+    use vortex_mask::Mask;
+
+    use super::*;
+
+    #[test]
+    fn test_bool_vector_eq_with_validity_127() {
+        // Test with 127 elements (not a multiple of 64, tests edge cases)
+        let len = 127;
+
+        // Create bits: alternating true/false pattern
+        let bits1: Vec<bool> = (0..len).map(|i| i % 2 == 0).collect();
+        let mut bits2: Vec<bool> = bits1.clone();
+
+        // Create validity: every 3rd element is invalid
+        let validity_bools: Vec<bool> = (0..len).map(|i| i % 3 != 0).collect();
+        let validity = Mask::from_buffer(BitBuffer::from(validity_bools));
+
+        let v1 = BoolVector::new(BitBuffer::from(bits1.clone()), validity.clone());
+        let v2 = BoolVector::new(BitBuffer::from(bits2.clone()), validity.clone());
+
+        // Should be equal - same bits at valid positions
+        assert_eq!(v1, v2);
+
+        // Now modify bits2 at an INVALID position - should still be equal
+        bits2[0] = !bits2[0]; // Flip bit 0, which is invalid (0 % 3 == 0)
+        let v3 = BoolVector::new(BitBuffer::from(bits2.clone()), validity.clone());
+        assert_eq!(
+            v1, v3,
+            "Vectors should be equal when only invalid positions differ"
+        );
+
+        // Now modify bits2 at a VALID position - should NOT be equal
+        bits2[1] = !bits2[1]; // Flip bit 1, which is valid (1 % 3 != 0)
+        let v4 = BoolVector::new(BitBuffer::from(bits2), validity);
+        assert_ne!(v1, v4, "Vectors should differ when valid positions differ");
+
+        // Test with different validity patterns - should NOT be equal
+        let validity2 = Mask::new_true(len);
+        let v5 = BoolVector::new(BitBuffer::from(bits1), validity2);
+        assert_ne!(
+            v1, v5,
+            "Vectors with different validity should not be equal"
+        );
+    }
+}

vortex-vector/src/listview/vector.rs

@@ -17,6 +17,7 @@ use super::ListViewScalar;
 use super::ListViewVectorMut;
 use crate::Vector;
 use crate::match_each_integer_pvector;
+use crate::match_each_integer_pvector_pair;
 use crate::primitive::PrimitiveVector;
 use crate::vector_ops::VectorMutOps;
 use crate::vector_ops::VectorOps;
@@ -65,58 +66,91 @@ pub struct ListViewVector {
 }
 
 impl PartialEq for ListViewVector {
-    #[allow(clippy::cast_possible_truncation)]
     fn eq(&self, other: &Self) -> bool {
         if self.len != other.len {
             return false;
         }
-        // Validity patterns must match
         if self.validity != other.validity {
             return false;
         }
-        // Elements lengths must match
         if self.elements.len() != other.elements.len() {
             return false;
         }
-        // Build element-level mask: for each valid list, mark elements[offset..offset+size] as valid
-        let valid_slices: Vec<(usize, usize)> = (0..self.len)
-            .filter(|&i| self.validity.value(i))
-            .map(|i| {
-                let offset =
-                    match_each_integer_pvector!(&self.offsets, |v| { v.as_ref()[i] as usize });
-                let size = match_each_integer_pvector!(&self.sizes, |v| { v.as_ref()[i] as usize });
-                (offset, offset + size)
-            })
-            .collect();
-        let element_mask = Mask::from_slices(self.elements.len(), valid_slices);
-
-        // Clone elements and apply the element-level mask
-        let mut self_elements = self.elements.as_ref().clone();
-        let mut other_elements = other.elements.as_ref().clone();
-        self_elements.mask_validity(&element_mask);
-        other_elements.mask_validity(&element_mask);
-
-        // Compare masked elements
-        if self_elements != other_elements {
-            return false;
-        }
 
-        // Compare offsets and sizes at valid positions
-        (0..self.len).all(|i| {
-            if !self.validity.value(i) {
-                return true;
-            }
-            let self_offset =
-                match_each_integer_pvector!(&self.offsets, |v| { v.as_ref()[i] as usize });
-            let other_offset =
-                match_each_integer_pvector!(&other.offsets, |v| { v.as_ref()[i] as usize });
-            let self_size =
-                match_each_integer_pvector!(&self.sizes, |v| { v.as_ref()[i] as usize });
-            let other_size =
-                match_each_integer_pvector!(&other.sizes, |v| { v.as_ref()[i] as usize });
-            self_offset == other_offset && self_size == other_size
+        // Offsets and sizes must have matching types, then compare within the match
+        match_each_integer_pvector_pair!(
+            (&self.offsets, &other.offsets),
+            |self_offsets, other_offsets| {
+                match_each_integer_pvector_pair!(
+                    (&self.sizes, &other.sizes),
+                    |self_sizes, other_sizes| {
+                        listview_eq_impl(
+                            self.len,
+                            &self.validity,
+                            self.elements.as_ref(),
+                            other.elements.as_ref(),
+                            self_offsets,
+                            other_offsets,
+                            self_sizes,
+                            other_sizes,
+                        )
+                    },
+                    { false } // Size types don't match
+                )
+            },
+            { false } // Offset types don't match
+        )
+    }
+}
+
+/// Helper function for ListViewVector equality comparison.
+#[expect(clippy::too_many_arguments)]
+fn listview_eq_impl<O, S>(
+    len: usize,
+    validity: &Mask,
+    self_elements: &Vector,
+    other_elements: &Vector,
+    self_offsets: &crate::primitive::PVector<O>,
+    other_offsets: &crate::primitive::PVector<O>,
+    self_sizes: &crate::primitive::PVector<S>,
+    other_sizes: &crate::primitive::PVector<S>,
+) -> bool
+where
+    O: vortex_dtype::NativePType + Copy,
+    S: vortex_dtype::NativePType + Copy,
+    usize: TryFrom<O> + TryFrom<S>,
+{
+    // Build element-level mask: for each valid list, mark elements[offset..offset+size] as valid
+    let valid_slices: Vec<(usize, usize)> = (0..len)
+        .filter(|&i| validity.value(i))
+        .map(|i| {
+            let offset = self_offsets
+                .get_as::<usize>(i)
+                .vortex_expect("offset is valid and fits in usize");
+            let size = self_sizes
+                .get_as::<usize>(i)
+                .vortex_expect("size is valid and fits in usize");
+            (offset, offset + size)
         })
+        .collect();
+    let element_mask = Mask::from_slices(self_elements.len(), valid_slices);
+
+    // Clone elements and apply the element-level mask
+    let mut self_elems = self_elements.clone();
+    let mut other_elems = other_elements.clone();
+    self_elems.mask_validity(&element_mask);
+    other_elems.mask_validity(&element_mask);
+
+    if self_elems != other_elems {
+        return false;
     }
+
+    // Compare offsets and sizes at valid positions
+    (0..len).all(|i| {
+        !validity.value(i)
+            || (self_offsets.get_as::<usize>(i) == other_offsets.get_as::<usize>(i)
+                && self_sizes.get_as::<usize>(i) == other_sizes.get_as::<usize>(i))
+    })
 }
 
 impl ListViewVector {

vortex-vector/src/primitive/generic.rs

@@ -132,6 +132,23 @@ impl<T> PVector<T> {
         self.validity.value(index).then(|| &self.elements[index])
     }
 
+    /// Gets an element at the given index and converts it to type `U`.
+    ///
+    /// Returns `None` if:
+    /// - The element at the given index is null
+    /// - The conversion from `T` to `U` fails
+    ///
+    /// # Panics
+    ///
+    /// Panics if the index is out of bounds.
+    pub fn get_as<U>(&self, index: usize) -> Option<U>
+    where
+        U: TryFrom<T>,
+        T: Copy,
+    {
+        self.get(index).and_then(|&v| U::try_from(v).ok())
+    }
+
     /// Returns the internal [`Buffer`] of the [`PVector`].
     ///
     /// Note that the internal buffer may hold garbage data in place of nulls. That information is