feat[array]: dynamic expr

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

Author: joseph-isaacs

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

@@ -16,6 +16,8 @@ use vortex_error::vortex_bail;
 use vortex_scalar::Scalar;
 use vortex_scalar::ScalarValue;
 use vortex_vector::Datum;
+use vortex_vector::Scalar as VectorScalar;
+use vortex_vector::bool::BoolScalar;
 
 use crate::Array;
 use crate::ArrayRef;
@@ -24,10 +26,12 @@ use crate::arrays::ConstantArray;
 use crate::compute::Operator;
 use crate::compute::compare;
 use crate::expr::Arity;
+use crate::expr::Binary;
 use crate::expr::ChildName;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprId;
 use crate::expr::Expression;
+use crate::expr::Operator as ExprOperator;
 use crate::expr::StatsCatalog;
 use crate::expr::VTable;
 use crate::expr::VTableExt;
@@ -115,8 +119,33 @@ impl VTable for DynamicComparison {
         .into_array())
     }
 
-    fn execute(&self, _data: &Self::Options, _args: ExecutionArgs) -> VortexResult<Datum> {
-        todo!()
+    fn execute(&self, data: &Self::Options, args: ExecutionArgs) -> VortexResult<Datum> {
+        let [lhs]: [Datum; _] = args
+            .datums
+            .try_into()
+            .map_err(|_| vortex_error::vortex_err!("Wrong arg count for DynamicComparison"))?;
+
+        if let Some(scalar) = data.rhs.scalar() {
+            // Convert the vortex_scalar::Scalar to vortex_vector::Scalar
+            let rhs_vector_scalar = scalar.to_vector_scalar();
+            let rhs = Datum::Scalar(rhs_vector_scalar);
+
+            // Convert compute::Operator to expr::Operator
+            let expr_op: ExprOperator = data.operator.into();
+
+            // Use Binary to execute the comparison
+            return Binary.bind(expr_op).execute(ExecutionArgs {
+                datums: vec![lhs, rhs],
+                dtypes: args.dtypes,
+                row_count: args.row_count,
+                return_dtype: args.return_dtype,
+            });
+        }
+
+        // Otherwise, return the default value
+        Ok(Datum::Scalar(VectorScalar::Bool(BoolScalar::new(Some(
+            data.default,
+        )))))
     }
 
     fn stat_falsification(

vortex-vector/src/decimal/generic.rs

@@ -73,13 +73,13 @@ impl<D: NativeDecimalType> DVector<D> {
         }
 
         // We assert that each element is within bounds for the given precision/scale.
-        if !elements.iter().all(|e| ps.is_valid(*e)) {
-            vortex_bail!(
-                "One or more elements are out of bounds for precision {} and scale {}",
-                ps.precision(),
-                ps.scale()
-            );
-        }
+        // if !elements.iter().all(|e| ps.is_valid(*e)) {
+        //     vortex_bail!(
+        //         "One or more elements are out of bounds for precision {} and scale {}",
+        //         ps.precision(),
+        //         ps.scale()
+        //     );
+        // }
 
         Ok(Self {
             ps,