fix

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

encodings/datetime-parts/src/compute/compare.rs

@@ -8,10 +8,10 @@ use vortex_array::arrays::ConstantArray;
 use vortex_array::compute::CompareKernel;
 use vortex_array::compute::CompareKernelAdapter;
 use vortex_array::compute::Operator;
-use vortex_array::compute::and;
+use vortex_array::compute::and_kleene;
 use vortex_array::compute::cast;
 use vortex_array::compute::compare;
-use vortex_array::compute::or;
+use vortex_array::compute::or_kleene;
 use vortex_array::register_kernel;
 use vortex_dtype::DType;
 use vortex_dtype::Nullability;
@@ -84,7 +84,7 @@ fn compare_eq(
         return Ok(Some(comparison));
     }
 
-    comparison = and(
+    comparison = and_kleene(
         &compare_dtp(lhs.seconds(), ts_parts.seconds, Operator::Eq, nullability)?,
         &comparison,
     )?;
@@ -94,7 +94,7 @@ fn compare_eq(
         return Ok(Some(comparison));
     }
 
-    comparison = and(
+    comparison = and_kleene(
         &compare_dtp(
             lhs.subseconds(),
             ts_parts.subseconds,
@@ -118,7 +118,7 @@ fn compare_ne(
         return Ok(Some(comparison));
     }
 
-    comparison = or(
+    comparison = or_kleene(
         &compare_dtp(
             lhs.seconds(),
             ts_parts.seconds,
@@ -133,7 +133,7 @@ fn compare_ne(
         return Ok(Some(comparison));
     }
 
-    comparison = or(
+    comparison = or_kleene(
         &compare_dtp(
             lhs.subseconds(),
             ts_parts.subseconds,

vortex-array/src/compute/between.rs

@@ -152,7 +152,7 @@ impl ComputeFnVTable for Between {
         Ok(boolean(
             &compare(lower, array, options.lower_strict.to_operator())?,
             &compare(array, upper, options.upper_strict.to_operator())?,
-            BooleanOperator::And,
+            BooleanOperator::AndKleene,
         )?
         .into())
     }

vortex-array/src/compute/boolean.rs

@@ -24,6 +24,7 @@ use crate::expr::operators::Operator;
 /// semantics is also known as "Bochvar logic" and "weak Kleene logic".
 ///
 /// See also [BooleanOperator::And]
+#[deprecated(note = "Use and_kleene instead. Non-Kleene boolean ops cannot be lazily evaluated.")]
 pub fn and(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
     boolean(lhs, rhs, BooleanOperator::And)
 }
@@ -41,6 +42,7 @@ pub fn and_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
 /// semantics is also known as "Bochvar logic" and "weak Kleene logic".
 ///
 /// See also [BooleanOperator::Or]
+#[deprecated(note = "Use or_kleene instead. Non-Kleene boolean ops cannot be lazily evaluated.")]
 pub fn or(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
     boolean(lhs, rhs, BooleanOperator::Or)
 }
@@ -53,16 +55,19 @@ pub fn or_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
 }
 
 /// Point-wise logical operator between two Boolean arrays.
-///
-/// This method uses Arrow-style null propagation rather than the Kleene logic semantics. This
-/// semantics is also known as "Bochvar logic" and "weak Kleene logic".
 pub fn boolean(lhs: &dyn Array, rhs: &dyn Array, op: BooleanOperator) -> VortexResult<ArrayRef> {
-    Ok(ScalarFnArray::try_new(
-        ScalarFn::new(Binary, Operator::try_from(op)?),
-        vec![lhs.to_array(), rhs.to_array()],
-        lhs.len(),
-    )?
-    .into_array())
+    match Operator::try_from(op) {
+        Ok(expr_op) => Ok(ScalarFnArray::try_new(
+            ScalarFn::new(Binary, expr_op),
+            vec![lhs.to_array(), rhs.to_array()],
+            lhs.len(),
+        )?
+        .into_array()),
+        Err(_) => {
+            tracing::trace!("non-Kleene boolean op {op:?} cannot be lazily evaluated, falling back to eager Arrow evaluation");
+            arrow_boolean(lhs.to_array(), rhs.to_array(), op)
+        }
+    }
 }
 
 /// Operations over the nullable Boolean values.
@@ -156,7 +161,7 @@ mod tests {
     #[case(BoolArray::from_iter([Some(true), Some(false), Some(true), Some(false)].into_iter()).into_array(),
         BoolArray::from_iter([Some(true), Some(true), Some(false), Some(false)].into_iter()).into_array())]
     fn test_or(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) {
-        let r = or(&lhs, &rhs).unwrap();
+        let r = or_kleene(&lhs, &rhs).unwrap();
 
         let r = r.to_bool().into_array();
 
@@ -178,7 +183,7 @@ mod tests {
     #[case(BoolArray::from_iter([Some(true), Some(false), Some(true), Some(false)].into_iter()).into_array(),
         BoolArray::from_iter([Some(true), Some(true), Some(false), Some(false)].into_iter()).into_array())]
     fn test_and(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) {
-        let r = and(&lhs, &rhs).unwrap().to_bool().into_array();
+        let r = and_kleene(&lhs, &rhs).unwrap().to_bool().into_array();
 
         let v0 = r.scalar_at(0).unwrap().as_bool().value();
         let v1 = r.scalar_at(1).unwrap().as_bool().value();

vortex-array/src/compute/conformance/consistency.rs

@@ -32,12 +32,12 @@ use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::PrimitiveArray;
 use crate::compute::Operator;
-use crate::compute::and;
+use crate::compute::and_kleene;
 use crate::compute::cast;
 use crate::compute::compare;
 use crate::compute::invert;
 use crate::compute::mask;
-use crate::compute::or;
+use crate::compute::or_kleene;
 
 /// Tests that filter and take operations produce consistent results.
 ///
@@ -899,11 +899,13 @@ fn test_boolean_demorgan_consistency(array: &dyn Array) {
     let mask = mask.as_ref();
 
     // Test first De Morgan's law: NOT(A AND B) = (NOT A) OR (NOT B)
-    if let (Ok(a_and_b), Ok(not_a), Ok(not_b)) = (and(array, mask), invert(array), invert(mask)) {
+    if let (Ok(a_and_b), Ok(not_a), Ok(not_b)) =
+        (and_kleene(array, mask), invert(array), invert(mask))
+    {
         let not_a_and_b =
             invert(&a_and_b).vortex_expect("invert should succeed in conformance test");
         let not_a_or_not_b =
-            or(&not_a, &not_b).vortex_expect("or should succeed in conformance test");
+            or_kleene(&not_a, &not_b).vortex_expect("or should succeed in conformance test");
 
         assert_eq!(
             not_a_and_b.len(),
@@ -927,10 +929,12 @@ fn test_boolean_demorgan_consistency(array: &dyn Array) {
     }
 
     // Test second De Morgan's law: NOT(A OR B) = (NOT A) AND (NOT B)
-    if let (Ok(a_or_b), Ok(not_a), Ok(not_b)) = (or(array, mask), invert(array), invert(mask)) {
+    if let (Ok(a_or_b), Ok(not_a), Ok(not_b)) =
+        (or_kleene(array, mask), invert(array), invert(mask))
+    {
         let not_a_or_b = invert(&a_or_b).vortex_expect("invert should succeed in conformance test");
         let not_a_and_not_b =
-            and(&not_a, &not_b).vortex_expect("and should succeed in conformance test");
+            and_kleene(&not_a, &not_b).vortex_expect("and should succeed in conformance test");
 
         for i in 0..not_a_or_b.len() {
             let left = not_a_or_b

vortex-array/src/compute/list_contains.rs

@@ -240,7 +240,7 @@ fn constant_list_scalar_contains(
         )?
         .fill_null(false_scalar.clone())?;
         if let Some(acc) = result {
-            result = Some(compute::or(&acc, &res)?)
+            result = Some(compute::or_kleene(&acc, &res)?)
         } else {
             result = Some(res);
         }

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

@@ -35,10 +35,12 @@ pub enum Operator {
     /// Boolean AND (∧).
     And,
     /// Boolean OR (∨).
+    // TODO(joe): rename to KleeneOr
     Or,
     /// The sum of the arguments.
     ///
     /// Errs at runtime if the sum would overflow or underflow.
+    // TODO(joe): rename to KleeneAnd
     Add,
     /// The difference between the arguments.
     ///