is-null

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

Author: joseph-isaacs

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

@@ -6,30 +6,32 @@ use std::ops::Not;
 
 use vortex_dtype::DType;
 use vortex_dtype::Nullability;
+use vortex_error::vortex_bail;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
 use vortex_mask::Mask;
+use vortex_vector::bool::BoolVector;
 use vortex_vector::Vector;
 use vortex_vector::VectorOps;
-use vortex_vector::bool::BoolVector;
 
-use crate::Array;
-use crate::ArrayRef;
-use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
-use crate::expr::ChildName;
+use crate::expr::exprs::binary::eq;
+use crate::expr::exprs::literal::lit;
+use crate::expr::functions::EmptyOptions;
+use crate::expr::stats::Stat;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprId;
 use crate::expr::Expression;
 use crate::expr::ExpressionView;
 use crate::expr::StatsCatalog;
 use crate::expr::VTable;
 use crate::expr::VTableExt;
-use crate::expr::exprs::binary::eq;
-use crate::expr::exprs::literal::lit;
-use crate::expr::stats::Stat;
+use crate::expr::{ChildName, ScalarFnExprExt};
+use crate::scalar_fns::is_null;
+use crate::Array;
+use crate::ArrayRef;
+use crate::IntoArray;
 
 /// Expression that checks for null values.
 pub struct IsNull;
@@ -110,6 +112,10 @@ impl VTable for IsNull {
     fn is_fallible(&self, _instance: &Self::Instance) -> bool {
         false
     }
+
+    fn expr_v2(&self, view: &ExpressionView<Self>) -> VortexResult<Expression> {
+        ScalarFnExprExt::try_new_expr(&is_null::IsNull, EmptyOptions, view.children().clone())
+    }
 }
 
 /// Creates an expression that checks for null values.
@@ -138,7 +144,6 @@ mod tests {
     use vortex_utils::aliases::hash_set::HashSet;
 
     use super::is_null;
-    use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::expr::exprs::binary::eq;
@@ -149,6 +154,7 @@ mod tests {
     use crate::expr::pruning::checked_pruning_expr;
     use crate::expr::stats::Stat;
     use crate::expr::test_harness;
+    use crate::IntoArray;
 
     #[test]
     fn dtype() {

vortex-array/src/expr/vtable.rs

@@ -8,6 +8,7 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hash;
 use std::hash::Hasher;
+use std::ops::Deref;
 use std::sync::Arc;
 
 use arcref::ArcRef;
@@ -152,6 +153,12 @@ pub trait VTable: 'static + Sized + Send + Sync {
         _ = instance;
         true
     }
+
+    /// **For internal usage**. This will return an Expression that is part of the
+    /// expression -> new_expression migration.
+    fn expr_v2(&self, expr: &ExpressionView<Self>) -> VortexResult<Expression> {
+        Ok(expr.deref().clone())
+    }
 }
 
 /// Arguments for expression execution.

vortex-array/src/scalar_fns/is_null/mod.rs

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_dtype::Nullability::NonNullable;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+use vortex_vector::Datum;
+use vortex_vector::Scalar;
+use vortex_vector::ScalarOps;
+use vortex_vector::Vector;
+use vortex_vector::VectorOps;
+use vortex_vector::bool::BoolScalar;
+use vortex_vector::bool::BoolVector;
+
+use crate::expr::ChildName;
+use crate::expr::ExprId;
+use crate::expr::functions::ArgName;
+use crate::expr::functions::Arity;
+use crate::expr::functions::EmptyOptions;
+use crate::expr::functions::ExecutionArgs;
+use crate::expr::functions::VTable;
+
+pub struct IsNull;
+impl VTable for IsNull {
+    type Options = EmptyOptions;
+
+    fn id(&self) -> ExprId {
+        ExprId::new_ref("is_null")
+    }
+
+    fn arity(&self, _: &Self::Options) -> Arity {
+        Arity::Fixed(1)
+    }
+
+    fn arg_name(&self, _: &Self::Options, arg_idx: usize) -> ArgName {
+        match arg_idx {
+            0 => ChildName::from("input"),
+            _ => unreachable!("Invalid child index {} for IsNull expression", arg_idx),
+        }
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _arg_types: &[DType]) -> VortexResult<DType> {
+        Ok(DType::Bool(NonNullable))
+    }
+
+    fn execute(&self, _: &Self::Options, args: &ExecutionArgs) -> VortexResult<Datum> {
+        Ok(args.input_datums(0).as_ref().map2(
+            |sc| sc.is_invalid().into(),
+            |arr| {
+                Vector::Bool(BoolVector::new(
+                    arr.validity().to_bit_buffer(),
+                    Mask::AllTrue(arr.len()),
+                ))
+            },
+        ))
+    }
+}

vortex-array/src/scalar_fns/mod.rs

@@ -19,6 +19,7 @@ use crate::expr::Expression;
 use crate::expr::ScalarFnExprExt;
 
 pub mod cast;
+pub mod is_null;
 
 /// A collection of built-in scalar functions that can be applied to expressions or arrays.
 pub trait BuiltinScalarFns: Sized {

vortex-vector/src/bool/scalar.rs

@@ -43,3 +43,9 @@ impl From<BoolScalar> for Scalar {
         Scalar::Bool(val)
     }
 }
+
+impl From<bool> for Scalar {
+    fn from(value: bool) -> Self {
+        BoolScalar::new(Some(value)).into()
+    }
+}

vortex-vector/src/datum.rs

@@ -81,6 +81,18 @@ impl Datum {
             Datum::Vector(vector) => Some(vector),
         }
     }
+
+    /// Maps over the scalar or vector value, applying the appropriate function based on the variant.
+    pub fn map2(
+        self,
+        sc_fn: impl FnOnce(Scalar) -> Scalar,
+        arr_fn: impl FnOnce(Vector) -> Vector,
+    ) -> Datum {
+        match self {
+            Datum::Scalar(scalar) => Datum::Scalar(sc_fn(scalar)),
+            Datum::Vector(vector) => Datum::Vector(arr_fn(vector)),
+        }
+    }
 }
 
 impl Datum {