wip

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

Author: joseph-isaacs

vortex-compute/src/arithmetic/pvector.rs

@@ -161,7 +161,6 @@ where
 mod tests {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
-    use vortex_vector::VectorOps;
     use vortex_vector::primitive::PVector;
 
     use crate::arithmetic::Arithmetic;
@@ -175,14 +174,16 @@ mod tests {
         let right = PVector::new(buffer![10u32, 20, 30, 40], Mask::new_true(4));
 
         let result = Arithmetic::<WrappingAdd, _>::eval(left, &right);
-        assert_eq!(result.elements(), &buffer![11u32, 22, 33, 44]);
+        let expected = PVector::new_valid(buffer![11u32, 22, 33, 44]);
+        assert_eq!(result, expected);
     }
 
     #[test]
     fn test_add_scalar() {
         let vec = PVector::new(buffer![1u32, 2, 3, 4], Mask::new_true(4));
         let result = Arithmetic::<WrappingAdd, _>::eval(vec, &10);
-        assert_eq!(result.elements(), &buffer![11u32, 12, 13, 14]);
+        let expected = PVector::new_valid(buffer![11u32, 12, 13, 14]);
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -192,8 +193,8 @@ mod tests {
 
         let result = Arithmetic::<WrappingAdd, _>::eval(left, &right);
         // Validity is AND'd, so if either side is null, result is null
-        assert_eq!(result.validity(), &Mask::from_iter([true, false, true]));
-        assert_eq!(result.elements(), &buffer![11u32, 22, 33]);
+        let expected = PVector::new(buffer![11u32, 22, 33], Mask::from_iter([true, false, true]));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -202,14 +203,16 @@ mod tests {
         let right = PVector::new(buffer![1u32, 2, 3, 4], Mask::new_true(4));
 
         let result = Arithmetic::<WrappingSub, _>::eval(left, &right);
-        assert_eq!(result.elements(), &buffer![9u32, 18, 27, 36]);
+        let expected = PVector::new_valid(buffer![9u32, 18, 27, 36]);
+        assert_eq!(result, expected);
     }
 
     #[test]
     fn test_sub_scalar() {
         let vec = PVector::new(buffer![10u32, 20, 30, 40], Mask::new_true(4));
         let result = Arithmetic::<WrappingSub, _>::eval(vec, &5);
-        assert_eq!(result.elements(), &buffer![5u32, 15, 25, 35]);
+        let expected = PVector::new_valid(buffer![5u32, 15, 25, 35]);
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -218,22 +221,23 @@ mod tests {
         let right = PVector::new(buffer![10u32, 20, 30, 40], Mask::new_true(4));
 
         let result = Arithmetic::<WrappingMul, _>::eval(left, &right);
-        assert_eq!(result.elements(), &buffer![20u32, 60, 120, 200]);
+        let expected = PVector::new_valid(buffer![20u32, 60, 120, 200]);
+        assert_eq!(result, expected);
     }
 
     #[test]
     fn test_mul_scalar() {
         let vec = PVector::new(buffer![1u32, 2, 3, 4], Mask::new_true(4));
         let result = Arithmetic::<WrappingMul, _>::eval(vec, &10);
-        assert_eq!(result.elements(), &buffer![10u32, 20, 30, 40]);
+        let expected = PVector::new_valid(buffer![10u32, 20, 30, 40]);
+        assert_eq!(result, expected);
     }
 
     #[test]
     fn test_scalar_preserves_validity() {
         let vec = PVector::new(buffer![1u32, 2, 3], Mask::from_iter([true, false, true]));
         let result = Arithmetic::<WrappingAdd, _>::eval(vec, &10);
-
-        assert_eq!(result.validity(), &Mask::from_iter([true, false, true]));
-        assert_eq!(result.elements(), &buffer![11u32, 12, 13]);
+        let expected = PVector::new(buffer![11u32, 12, 13], Mask::from_iter([true, false, true]));
+        assert_eq!(result, expected);
     }
 }

vortex-compute/src/comparison/pvector.rs

@@ -38,6 +38,7 @@ mod tests {
     use vortex_buffer::bitbuffer;
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
+    use vortex_vector::bool::BoolVector;
 
     use super::*;
     use crate::comparison::Equal;
@@ -53,7 +54,8 @@ mod tests {
         let right = PVector::new(buffer![1u32, 2, 5, 4], Mask::new_true(4));
 
         let result = Compare::<Equal>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![1 1 0 1]);
+        let expected = BoolVector::new(bitbuffer![1 1 0 1], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -62,7 +64,8 @@ mod tests {
         let right = PVector::new(buffer![1u32, 2, 5, 4], Mask::new_true(4));
 
         let result = Compare::<NotEqual>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![0 0 1 0]);
+        let expected = BoolVector::new(bitbuffer![0 0 1 0], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -71,7 +74,8 @@ mod tests {
         let right = PVector::new(buffer![2u32, 2, 1, 5], Mask::new_true(4));
 
         let result = Compare::<LessThan>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![1 0 0 1]);
+        let expected = BoolVector::new(bitbuffer![1 0 0 1], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -80,7 +84,8 @@ mod tests {
         let right = PVector::new(buffer![2u32, 2, 1, 5], Mask::new_true(4));
 
         let result = Compare::<LessThanOrEqual>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![1 1 0 1]);
+        let expected = BoolVector::new(bitbuffer![1 1 0 1], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -89,7 +94,8 @@ mod tests {
         let right = PVector::new(buffer![1u32, 2, 3, 4], Mask::new_true(4));
 
         let result = Compare::<GreaterThan>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![1 0 0 1]);
+        let expected = BoolVector::new(bitbuffer![1 0 0 1], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -98,7 +104,8 @@ mod tests {
         let right = PVector::new(buffer![1u32, 2, 3, 4], Mask::new_true(4));
 
         let result = Compare::<GreaterThanOrEqual>::compare(&left, &right);
-        assert_eq!(result.bits(), &bitbuffer![1 1 0 1]);
+        let expected = BoolVector::new(bitbuffer![1 1 0 1], Mask::new_true(4));
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -108,7 +115,7 @@ mod tests {
 
         let result = Compare::<Equal>::compare(&left, &right);
         // Validity is AND'd, so if either side is null, result validity is null
-        assert_eq!(result.validity(), &Mask::from_iter([true, false, true]));
-        assert_eq!(result.bits(), &bitbuffer![1 1 1]);
+        let expected = BoolVector::new(bitbuffer![1 1 1], Mask::from_iter([true, false, true]));
+        assert_eq!(result, expected);
     }
 }

vortex-vector/src/binaryview/scalar.rs

@@ -11,7 +11,7 @@ use crate::binaryview::BinaryViewVectorMut;
 use crate::binaryview::StringType;
 
 /// A scalar value for types that implement [`BinaryViewType`].
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct BinaryViewScalar<T: BinaryViewType>(Option<T::Scalar>);
 
 impl<T: BinaryViewType> BinaryViewScalar<T> {

vortex-vector/src/binaryview/types.rs

@@ -63,7 +63,7 @@ pub trait BinaryViewType: Debug + Sized + Send + Sync + 'static + private::Seale
 }
 
 /// [`BinaryType`] for UTF-8 strings.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct StringType;
 impl BinaryViewType for StringType {
     type Slice = str;
@@ -96,7 +96,7 @@ impl BinaryViewType for StringType {
 }
 
 /// [`BinaryType`] for raw binary data.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct BinaryType;
 impl BinaryViewType for BinaryType {
     type Slice = [u8];

vortex-vector/src/binaryview/vector.rs

@@ -38,6 +38,49 @@ pub struct BinaryViewVector<T: BinaryViewType> {
     _marker: std::marker::PhantomData<T>,
 }
 
+impl<T: BinaryViewType> PartialEq for BinaryViewVector<T> {
+    fn eq(&self, other: &Self) -> bool {
+        if self.views.len() != other.views.len() {
+            return false;
+        }
+        // Validity patterns must match
+        if self.validity != other.validity {
+            return false;
+        }
+        // Compare all views, OR with !validity to ignore invalid positions
+        self.views
+            .iter()
+            .zip(other.views.iter())
+            .enumerate()
+            .all(|(i, (self_view, other_view))| {
+                // If invalid, treat as equal
+                if !self.validity.value(i) {
+                    return true;
+                }
+                // For valid elements, compare the actual byte content via the view
+                let self_bytes: &[u8] = if self_view.is_inlined() {
+                    self_view.as_inlined().value()
+                } else {
+                    let view_ref = self_view.as_view();
+                    let buffer = &self.buffers[view_ref.buffer_index as usize];
+                    &buffer[view_ref.as_range()]
+                };
+
+                let other_bytes: &[u8] = if other_view.is_inlined() {
+                    other_view.as_inlined().value()
+                } else {
+                    let view_ref = other_view.as_view();
+                    let buffer = &other.buffers[view_ref.buffer_index as usize];
+                    &buffer[view_ref.as_range()]
+                };
+
+                self_bytes == other_bytes
+            })
+    }
+}
+
+impl<T: BinaryViewType> Eq for BinaryViewVector<T> {}
+
 impl<T: BinaryViewType> BinaryViewVector<T> {
     /// Creates a new [`BinaryViewVector`] from the provided components.
     ///

vortex-vector/src/bool/scalar.rs

@@ -8,7 +8,7 @@ use crate::VectorMutOps;
 use crate::bool::BoolVectorMut;
 
 /// A scalar value for boolean types.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct BoolScalar(Option<bool>);
 
 impl BoolScalar {

vortex-vector/src/bool/vector.rs

@@ -20,14 +20,44 @@ use crate::bool::BoolVectorMut;
 /// An immutable vector of boolean values.
 ///
 /// Internally, this `BoolVector` is a wrapper around a [`BitBuffer`] and a validity mask.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq)]
 pub struct BoolVector {
     /// The bits that we use to represent booleans.
     pub(super) bits: BitBuffer,
     /// The validity mask (where `true` represents an element is **not** null).
     pub(super) validity: Mask,
 }
 
+impl PartialEq for BoolVector {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+        // Validity patterns must match
+        if self.validity != other.validity {
+            return false;
+        }
+        // Use XNOR comparison: bits are equal where !(lhs ^ rhs) is true
+        let lhs_chunks = self.bits.chunks();
+        let rhs_chunks = other.bits.chunks();
+        let validity_bits = self.validity.to_bit_buffer();
+        let validity_chunks = validity_bits.chunks();
+
+        // For equality: check that !(lhs ^ rhs) & validity == validity at each chunk
+        for ((lhs, rhs), valid) in lhs_chunks
+            .iter_padded()
+            .zip(rhs_chunks.iter_padded())
+            .zip(validity_chunks.iter_padded())
+        {
+            let equal_bits = !(lhs ^ rhs); // XNOR: true where bits are equal
+            if (equal_bits & valid) != valid {
+                return false;
+            }
+        }
+        true
+    }
+}
+
 impl BoolVector {
     /// Creates a new [`BoolVector`] from the given bits and validity mask.
     ///

vortex-vector/src/decimal/generic.rs

@@ -36,6 +36,30 @@ pub struct DVector<D> {
     pub(super) validity: Mask,
 }
 
+impl<D: NativeDecimalType + PartialEq> PartialEq for DVector<D> {
+    fn eq(&self, other: &Self) -> bool {
+        if self.elements.len() != other.elements.len() {
+            return false;
+        }
+        // Precision and scale must match
+        if self.ps != other.ps {
+            return false;
+        }
+        // Validity patterns must match
+        if self.validity != other.validity {
+            return false;
+        }
+        // Compare all elements, OR with !validity to ignore invalid positions
+        self.elements
+            .iter()
+            .zip(other.elements.iter())
+            .enumerate()
+            .all(|(i, (a, b))| !self.validity.value(i) || a == b)
+    }
+}
+
+impl<D: NativeDecimalType + Eq> Eq for DVector<D> {}
+
 impl<D: NativeDecimalType> DVector<D> {
     /// Creates a new [`DVector<D>`] from the given [`PrecisionScale`], elements buffer, and
     /// validity mask.

vortex-vector/src/decimal/scalar.rs

@@ -14,7 +14,7 @@ use crate::VectorMutOps;
 use crate::decimal::DVectorMut;
 
 /// Represents a decimal scalar value.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum DecimalScalar {
     /// 8-bit decimal scalar.
     D8(DScalar<i8>),

vortex-vector/src/decimal/vector.rs

@@ -21,7 +21,7 @@ use crate::decimal::DecimalVectorMut;
 use crate::match_each_dvector;
 
 /// An enum over all supported decimal mutable vector types.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq)]
 pub enum DecimalVector {
     /// A decimal vector with 8-bit integer representation.
     D8(DVector<i8>),
@@ -37,6 +37,20 @@ pub enum DecimalVector {
     D256(DVector<i256>),
 }
 
+impl PartialEq for DecimalVector {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (DecimalVector::D8(a), DecimalVector::D8(b)) => a == b,
+            (DecimalVector::D16(a), DecimalVector::D16(b)) => a == b,
+            (DecimalVector::D32(a), DecimalVector::D32(b)) => a == b,
+            (DecimalVector::D64(a), DecimalVector::D64(b)) => a == b,
+            (DecimalVector::D128(a), DecimalVector::D128(b)) => a == b,
+            (DecimalVector::D256(a), DecimalVector::D256(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
 impl DecimalVector {
     /// Returns the precision of the decimal vector.
     pub fn precision(&self) -> u8 {