Remove selection mask

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

encodings/sequence/src/array.rs

@@ -4,8 +4,10 @@
 use std::hash::Hash;
 use std::ops::Range;
 
+use num_traits::One;
 use num_traits::cast::FromPrimitive;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::execution::ExecutionCtx;
 use vortex_array::serde::ArrayChildren;
 use vortex_array::stats::{ArrayStats, StatsSetRef};
 use vortex_array::vtable::{
@@ -24,6 +26,8 @@ use vortex_dtype::{
 use vortex_error::{VortexExpect, VortexResult, vortex_bail, vortex_err};
 use vortex_mask::Mask;
 use vortex_scalar::{PValue, Scalar, ScalarValue};
+use vortex_vector::Vector;
+use vortex_vector::primitive::PVector;
 
 vtable!(Sequence);
 
@@ -242,6 +246,26 @@ impl VTable for SequenceVTable {
             len,
         ))
     }
+
+    fn execute(array: &Self::Array, _ctx: &mut dyn ExecutionCtx) -> VortexResult<Vector> {
+        Ok(match_each_native_ptype!(array.ptype(), |P| {
+            let base = array.base().cast::<P>();
+            let multiplier = array.multiplier().cast::<P>();
+
+            let values = if multiplier == <P>::one() {
+                BufferMut::from_iter(
+                    (0..array.len()).map(|i| base + <P>::from_usize(i).vortex_expect("must fit")),
+                )
+            } else {
+                BufferMut::from_iter(
+                    (0..array.len())
+                        .map(|i| base + <P>::from_usize(i).vortex_expect("must fit") * multiplier),
+                )
+            };
+
+            PVector::<P>::new(values.freeze(), Mask::new_true(array.len())).into()
+        }))
+    }
 }
 
 impl ArrayVTable<SequenceVTable> for SequenceVTable {

vortex-array/src/expr/exprs/get_item/mod.rs

@@ -7,9 +7,11 @@ use std::fmt::Formatter;
 use std::ops::Not;
 
 use prost::Message;
+use vortex_compute::mask::MaskValidity;
 use vortex_dtype::{DType, FieldName, FieldPath, Nullability};
 use vortex_error::{VortexResult, vortex_bail, vortex_err};
 use vortex_proto::expr as pb;
+use vortex_vector::{Vector, VectorOps};
 
 use crate::compute::mask;
 use crate::expr::exprs::root::root;
@@ -96,6 +98,29 @@ impl VTable for GetItem {
         }
     }
 
+    fn execute(
+        &self,
+        expr: &ExpressionView<Self>,
+        vector: &Vector,
+        dtype: &DType,
+    ) -> VortexResult<Vector> {
+        let child_dtype = expr.child(0).return_dtype(dtype)?;
+        let struct_dtype = child_dtype
+            .as_struct_fields_opt()
+            .ok_or_else(|| vortex_err!("Expected struct dtype for child of GetItem expression"))?;
+        let field_idx = struct_dtype
+            .find(expr.data())
+            .ok_or_else(|| vortex_err!("Field {} not found in struct dtype", expr.data()))?;
+
+        let struct_vector = expr.child(0).execute(vector, dtype)?.into_struct();
+
+        // We must intersect the validity with that of the parent struct
+        let field = struct_vector.fields()[field_idx].clone();
+        let field = MaskValidity::mask_validity(field, struct_vector.validity());
+
+        Ok(field)
+    }
+
     fn stat_max(
         &self,
         expr: &ExpressionView<Self>,

vortex-array/src/expr/exprs/is_null.rs

@@ -7,6 +7,8 @@ use std::ops::Not;
 use vortex_dtype::{DType, Nullability};
 use vortex_error::{VortexResult, vortex_bail};
 use vortex_mask::Mask;
+use vortex_vector::bool::BoolVector;
+use vortex_vector::{Vector, VectorOps};
 
 use crate::arrays::{BoolArray, ConstantArray};
 use crate::expr::exprs::binary::eq;
@@ -69,6 +71,20 @@ impl VTable for IsNull {
         }
     }
 
+    fn execute(
+        &self,
+        expr: &ExpressionView<Self>,
+        vector: &Vector,
+        dtype: &DType,
+    ) -> VortexResult<Vector> {
+        let child = expr.child(0).execute(vector, dtype)?;
+        Ok(BoolVector::new(
+            child.validity().to_bit_buffer().not(),
+            Mask::new_true(child.len()),
+        )
+        .into())
+    }
+
     fn stat_falsification(
         &self,
         expr: &ExpressionView<Self>,

vortex-array/src/expr/exprs/not.rs

@@ -3,8 +3,10 @@
 
 use std::fmt::Formatter;
 
+use vortex_compute::logical::LogicalNot;
 use vortex_dtype::DType;
 use vortex_error::{VortexResult, vortex_bail};
+use vortex_vector::Vector;
 
 use crate::ArrayRef;
 use crate::compute::invert;
@@ -66,6 +68,16 @@ impl VTable for Not {
         let child_result = expr.child(0).evaluate(scope)?;
         invert(&child_result)
     }
+
+    fn execute(
+        &self,
+        expr: &ExpressionView<Self>,
+        vector: &Vector,
+        dtype: &DType,
+    ) -> VortexResult<Vector> {
+        let child = expr.child(0).execute(vector, dtype)?;
+        Ok(child.into_bool().not().into())
+    }
 }
 
 /// Creates an expression that logically inverts boolean values.

vortex-array/src/expr/exprs/root.rs

@@ -5,6 +5,7 @@ use std::fmt::Formatter;
 
 use vortex_dtype::{DType, FieldPath};
 use vortex_error::{VortexExpect, VortexResult, vortex_bail};
+use vortex_vector::Vector;
 
 use crate::ArrayRef;
 use crate::expr::expression::Expression;
@@ -59,6 +60,15 @@ impl VTable for Root {
         Ok(scope.clone())
     }
 
+    fn execute(
+        &self,
+        _expr: &ExpressionView<Self>,
+        vector: &Vector,
+        _dtype: &DType,
+    ) -> VortexResult<Vector> {
+        Ok(vector.clone())
+    }
+
     fn stat_max(
         &self,
         expr: &ExpressionView<Root>,