Flat Layout Execution

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

Author: gatesn

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

@@ -6,25 +6,26 @@ use std::fmt::Formatter;
 use prost::Message;
 use vortex_dtype::DType;
 use vortex_dtype::DType::Bool;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
 use vortex_proto::expr as pb;
 use vortex_vector::Datum;
 
-use crate::ArrayRef;
-use crate::compute::BetweenOptions;
 use crate::compute::between as between_compute;
+use crate::compute::BetweenOptions;
+use crate::expr::expression::Expression;
+use crate::expr::exprs::binary::Binary;
+use crate::expr::exprs::operators::Operator;
 use crate::expr::Arity;
 use crate::expr::ChildName;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprId;
 use crate::expr::StatsCatalog;
 use crate::expr::VTable;
 use crate::expr::VTableExt;
-use crate::expr::expression::Expression;
-use crate::expr::exprs::binary::Binary;
-use crate::expr::exprs::operators::Operator;
+use crate::ArrayRef;
 
 /// An optimized scalar expression to compute whether values fall between two bounds.
 ///
@@ -149,8 +150,39 @@ impl VTable for Between {
         between_compute(&arr, &lower, &upper, options)
     }
 
-    fn execute(&self, _data: &Self::Options, _args: ExecutionArgs) -> VortexResult<Datum> {
-        todo!()
+    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<Datum> {
+        let [arr, lower, upper]: [Datum; _] = args
+            .datums
+            .try_into()
+            .map_err(|_| vortex_err!("Expected 3 arguments for Between expression",))?;
+        let [arr_dt, lower_dt, upper_dt]: [DType; _] = args
+            .dtypes
+            .try_into()
+            .map_err(|_| vortex_err!("Expected 3 dtypes for Between expression",))?;
+
+        let lower_bound = Binary
+            .bind(options.lower_strict.to_operator().into())
+            .execute(ExecutionArgs {
+                datums: vec![lower.clone(), arr.clone()],
+                dtypes: vec![lower_dt.clone(), arr_dt.clone()],
+                row_count: args.row_count,
+                return_dtype: args.return_dtype.clone(),
+            })?;
+        let upper_bound = Binary
+            .bind(options.upper_strict.to_operator().into())
+            .execute(ExecutionArgs {
+                datums: vec![arr.clone(), upper.clone()],
+                dtypes: vec![arr_dt.clone(), upper_dt.clone()],
+                row_count: args.row_count,
+                return_dtype: args.return_dtype.clone(),
+            })?;
+
+        Binary.bind(Operator::And).execute(ExecutionArgs {
+            datums: vec![lower_bound, upper_bound],
+            dtypes: vec![args.return_dtype.clone(), args.return_dtype.clone()],
+            row_count: args.row_count,
+            return_dtype: args.return_dtype.clone(),
+        })
     }
 
     fn stat_falsification(

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

@@ -13,16 +13,15 @@ use vortex_compute::arithmetic::Div;
 use vortex_compute::arithmetic::Mul;
 use vortex_compute::arithmetic::Sub;
 use vortex_dtype::DType;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
 use vortex_proto::expr as pb;
 use vortex_vector::Datum;
 use vortex_vector::PrimitiveDatum;
 use vortex_vector::Vector;
 
-use crate::ArrayRef;
 use crate::compute;
 use crate::compute::add;
 use crate::compute::and_kleene;
@@ -31,17 +30,18 @@ use crate::compute::div;
 use crate::compute::mul;
 use crate::compute::or_kleene;
 use crate::compute::sub;
+use crate::expr::expression::Expression;
+use crate::expr::exprs::literal::lit;
+use crate::expr::exprs::operators::Operator;
+use crate::expr::stats::Stat;
 use crate::expr::Arity;
 use crate::expr::ChildName;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprId;
 use crate::expr::StatsCatalog;
 use crate::expr::VTable;
 use crate::expr::VTableExt;
-use crate::expr::expression::Expression;
-use crate::expr::exprs::literal::lit;
-use crate::expr::exprs::operators::Operator;
-use crate::expr::stats::Stat;
+use crate::ArrayRef;
 
 pub struct Binary;
 
@@ -140,6 +140,24 @@ impl VTable for Binary {
             .try_into()
             .map_err(|_| vortex_err!("Wrong arg count"))?;
 
+        match op {
+            Operator::And => {
+                let lhs = lhs.ensure_vector(args.row_count).into_bool().into();
+                let rhs = rhs.ensure_vector(args.row_count).into_bool().into();
+                return Ok(Datum::Vector(Vector::try_from(
+                    &arrow_arith::boolean::and_kleene(&lhs, &rhs)? as &dyn Array,
+                )?));
+            }
+            Operator::Or => {
+                let lhs = lhs.ensure_vector(args.row_count).into_bool().into();
+                let rhs = rhs.ensure_vector(args.row_count).into_bool().into();
+                return Ok(Datum::Vector(Vector::try_from(
+                    &arrow_arith::boolean::or_kleene(&lhs, &rhs)? as &dyn Array,
+                )?));
+            }
+            _ => {}
+        }
+
         let lhs: Box<dyn arrow_array::Datum> = lhs.try_into()?;
         let rhs: Box<dyn arrow_array::Datum> = rhs.try_into()?;
 
@@ -169,7 +187,9 @@ impl VTable for Binary {
             Operator::Div => {
                 Vector::try_from(arrow_arith::numeric::div(lhs.as_ref(), rhs.as_ref())?.as_ref())?
             }
-            _ => vortex_bail!("Unsupported operator in execute: {}", op),
+            Operator::And | Operator::Or => {
+                unreachable!("Already dealt with above")
+            }
         };
 
         Ok(Datum::Vector(vector))
@@ -597,10 +617,10 @@ mod tests {
     use super::lt_eq;
     use super::not_eq;
     use super::or;
-    use crate::expr::Expression;
     use crate::expr::exprs::get_item::col;
     use crate::expr::exprs::literal::lit;
     use crate::expr::test_harness;
+    use crate::expr::Expression;
 
     #[test]
     fn and_collect_left_assoc() {

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

@@ -3,23 +3,26 @@
 
 use std::fmt::Formatter;
 
+use arrow_array::cast::AsArray;
 use prost::Message;
 use vortex_dtype::DType;
-use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+use vortex_error::VortexResult;
 use vortex_proto::expr as pb;
+use vortex_vector::bool::BoolVector;
 use vortex_vector::Datum;
 
-use crate::ArrayRef;
-use crate::compute::LikeOptions;
 use crate::compute::like as like_compute;
+use crate::compute::LikeOptions;
 use crate::expr::Arity;
 use crate::expr::ChildName;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprId;
 use crate::expr::Expression;
 use crate::expr::VTable;
 use crate::expr::VTableExt;
+use crate::ArrayRef;
 
 /// Expression that performs SQL LIKE pattern matching.
 pub struct Like;
@@ -109,8 +112,27 @@ impl VTable for Like {
         like_compute(&child, &pattern, *options)
     }
 
-    fn execute(&self, _data: &Self::Options, _args: ExecutionArgs) -> VortexResult<Datum> {
-        todo!()
+    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<Datum> {
+        let [child, pattern]: [Datum; _] = args
+            .datums
+            .try_into()
+            .map_err(|_| vortex_err!("Wrong argument count"))?;
+
+        let child: Box<dyn arrow_array::Datum> = child.try_into()?;
+        let pattern: Box<dyn arrow_array::Datum> = pattern.try_into()?;
+
+        let array = pattern.get().0;
+        let sv = array.as_string_view();
+        println!("STRING VIEW PATTERN: {:?}", sv);
+
+        let array = match (options.negated, options.case_insensitive) {
+            (false, false) => arrow_string::like::like(child.as_ref(), pattern.as_ref()),
+            (false, true) => arrow_string::like::ilike(child.as_ref(), pattern.as_ref()),
+            (true, false) => arrow_string::like::nlike(child.as_ref(), pattern.as_ref()),
+            (true, true) => arrow_string::like::nilike(child.as_ref(), pattern.as_ref()),
+        }?;
+
+        Ok(Datum::Vector(BoolVector::from(&array).into()))
     }
 
     fn is_null_sensitive(&self, _instance: &Self::Options) -> bool {
@@ -163,14 +185,14 @@ mod tests {
     use vortex_dtype::DType;
     use vortex_dtype::Nullability;
 
-    use crate::ToCanonical;
     use crate::arrays::BoolArray;
     use crate::expr::exprs::get_item::get_item;
     use crate::expr::exprs::like::like;
     use crate::expr::exprs::like::not_ilike;
     use crate::expr::exprs::literal::lit;
     use crate::expr::exprs::not::not;
     use crate::expr::exprs::root::root;
+    use crate::ToCanonical;
 
     #[test]
     fn invert_booleans() {

vortex-vector/src/arrow/bool.rs

@@ -9,8 +9,8 @@ use arrow_array::Array;
 use arrow_array::ArrayRef;
 use arrow_array::BooleanArray;
 use vortex_buffer::BitBuffer;
-use vortex_error::VortexError;
 use vortex_error::vortex_err;
+use vortex_error::VortexError;
 
 impl TryFrom<BoolVector> for ArrayRef {
     type Error = VortexError;
@@ -21,6 +21,13 @@ impl TryFrom<BoolVector> for ArrayRef {
     }
 }
 
+impl From<BoolVector> for BooleanArray {
+    fn from(value: BoolVector) -> Self {
+        let (bits, validity) = value.into_parts();
+        BooleanArray::new(bits.into(), validity.into())
+    }
+}
+
 impl From<&BooleanArray> for BoolVector {
     fn from(value: &BooleanArray) -> Self {
         let bits = BitBuffer::from(value.values().clone());