Fix pruning expressions with and / or (#2595)

Author: onursatici

vortex-array/src/compute/between.rs

@@ -54,7 +54,7 @@ where
     }
 }
 
-/// Compute between (a <= x <= b), this can be implemented using compare and boolean andn but this
+/// Compute between (a <= x <= b), this can be implemented using compare and boolean and but this
 /// will likely have a lower runtime.
 ///
 /// This semantics is equivalent to:

vortex-expr/src/operators.rs

@@ -47,6 +47,14 @@ impl Operator {
         }
     }
 
+    pub fn logical_inverse(self) -> Option<Self> {
+        match self {
+            Operator::And => Some(Operator::Or),
+            Operator::Or => Some(Operator::And),
+            _ => None,
+        }
+    }
+
     /// Change the sides of the operator, where changing lhs and rhs won't change the result of the operation
     pub fn swap(self) -> Self {
         match self {

vortex-expr/src/pruning.rs

@@ -10,7 +10,7 @@ use vortex_array::aliases::hash_set::HashSet;
 use vortex_array::stats::Stat;
 use vortex_array::{Array, ArrayRef};
 use vortex_dtype::{FieldName, Nullability};
-use vortex_error::{VortexExpect as _, VortexResult};
+use vortex_error::{VortexExpect, VortexResult};
 use vortex_scalar::Scalar;
 
 use crate::between::Between;
@@ -184,8 +184,12 @@ fn convert_to_pruning_expression(expr: &ExprRef) -> PruningPredicateStats {
             let (rewritten_left, mut refs_lhs) = convert_to_pruning_expression(bexp.lhs());
             let (rewritten_right, refs_rhs) = convert_to_pruning_expression(bexp.rhs());
             refs_lhs.extend(refs_rhs);
+            let flipped_op = bexp
+                .op()
+                .logical_inverse()
+                .vortex_expect("Can not be any other operator than and / or");
             return (
-                BinaryExpr::new_expr(rewritten_left, bexp.op(), rewritten_right),
+                BinaryExpr::new_expr(rewritten_left, flipped_op, rewritten_right),
                 refs_lhs,
             );
         }
@@ -705,10 +709,29 @@ mod tests {
         let predicate = PruningPredicate::try_new(&expr).unwrap();
         assert_eq!(predicate.required_stats(), &expected);
 
-        let expected_expr = or(
+        let expected_expr = and(
             gt_eq(get_item_scope(FieldName::from("min")), lit(10)),
             lt_eq(get_item_scope(FieldName::from("max")), lit(50)),
         );
         assert_eq!(predicate.expr(), &expected_expr)
     }
+    #[test]
+    pub fn pruning_and_or_operators() {
+        // Test case: a > 10 AND a < 50
+        let column = FieldName::from("a");
+        let and_expr = and(
+            gt(get_item_scope(column.clone()), lit(10)),
+            lt(get_item_scope(column), lit(50)),
+        );
+        let pruned = PruningPredicate::try_new(&and_expr).unwrap();
+
+        // Expected: a_max <= 10 OR a_min >= 50
+        assert_eq!(
+            pruned.expr(),
+            &or(
+                lt_eq(get_item_scope(FieldName::from("a_max")), lit(10)),
+                gt_eq(get_item_scope(FieldName::from("a_min")), lit(50))
+            ),
+        );
+    }
 }