update

Author: alamb

datafusion/src/optimizer/simplify_expressions.rs

@@ -284,10 +284,10 @@ impl OptimizerRule for SimplifyExpressions {
         // expressions that references non-projected columns within the same project plan or its
         // children plans.
         let mut simplifier =
-            super::simplify_expressions::Simplifier::new(plan.all_schemas());
+            Simplifier::new(plan.all_schemas());
 
         let mut const_evaluator =
-            super::simplify_expressions::ConstEvaluator::new(execution_props);
+            ConstEvaluator::new(execution_props);
 
         let new_inputs = plan
             .inputs()
@@ -649,6 +649,8 @@ impl<'a> ExprRewriter for Simplifier<'a> {
 
         let new_expr = match expr {
             BinaryExpr { left, op, right } => match op {
+                // true = A  --> A
+                // false = A --> !A
                 Operator::Eq => match (left.as_ref(), right.as_ref()) {
                     (Literal(Boolean(l)), Literal(Boolean(r))) => match (l, r) {
                         (Some(l), Some(r)) => Literal(Boolean(Some(l == r))),
@@ -670,6 +672,8 @@ impl<'a> ExprRewriter for Simplifier<'a> {
                         right,
                     },
                 },
+                // true != A  --> !A
+                // false != A --> A
                 Operator::NotEq => match (left.as_ref(), right.as_ref()) {
                     (Literal(Boolean(l)), Literal(Boolean(r))) => match (l, r) {
                         (Some(l), Some(r)) => Literal(Boolean(Some(l != r))),
@@ -745,6 +749,8 @@ impl<'a> ExprRewriter for Simplifier<'a> {
     }
 }
 
+
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -910,12 +916,12 @@ mod tests {
     }
 
     #[test]
-    fn test_simplify_do_not_simplify_arithmetic_expr() {
+    fn test_simplify_simplify_arithmetic_expr() {
         let expr_plus = binary_expr(lit(1), Operator::Plus, lit(1));
         let expr_eq = binary_expr(lit(1), Operator::Eq, lit(1));
 
-        assert_eq!(simplify(expr_plus.clone()), expr_plus);
-        assert_eq!(simplify(expr_eq.clone()), expr_eq);
+        assert_eq!(simplify(expr_plus), lit(2));
+        assert_eq!(simplify(expr_eq), lit(true));
     }
 
     // ------------------------------
@@ -1162,7 +1168,15 @@ mod tests {
     fn simplify(expr: Expr) -> Expr {
         let schema = expr_test_schema();
         let mut rewriter = Simplifier::new(vec![&schema]);
-        expr.rewrite(&mut rewriter).expect("expected to simplify")
+
+        let execution_props = ExecutionProps::new();
+        let mut const_evaluator =
+            ConstEvaluator::new(&execution_props);
+
+        expr.rewrite(&mut rewriter)
+            .expect("expected to simplify")
+            .rewrite(&mut const_evaluator)
+            .expect("expected to const evaluate")
     }
 
     fn expr_test_schema() -> DFSchemaRef {
@@ -1238,16 +1252,8 @@ mod tests {
         // Make sure c1 column to be used in tests is not boolean type
         assert_eq!(col("c1").get_type(&schema).unwrap(), DataType::Utf8);
 
-        // don't fold c1 = true
-        assert_eq!(simplify(col("c1").eq(lit(true))), col("c1").eq(lit(true)),);
-
-        // don't fold c1 = false
-        assert_eq!(simplify(col("c1").eq(lit(false))), col("c1").eq(lit(false)),);
-
-        // test constant operands
-        assert_eq!(simplify(lit(1).eq(lit(true))), lit(1).eq(lit(true)),);
-
-        assert_eq!(simplify(lit("a").eq(lit(false))), lit("a").eq(lit(false)),);
+        // don't fold c1 = foo
+        assert_eq!(simplify(col("c1").eq(lit("foo"))), col("c1").eq(lit("foo")),);
     }
 
     #[test]
@@ -1278,21 +1284,8 @@ mod tests {
         assert_eq!(col("c1").get_type(&schema).unwrap(), DataType::Utf8);
 
         assert_eq!(
-            simplify(col("c1").not_eq(lit(true))),
-            col("c1").not_eq(lit(true)),
-        );
-
-        assert_eq!(
-            simplify(col("c1").not_eq(lit(false))),
-            col("c1").not_eq(lit(false)),
-        );
-
-        // test constants
-        assert_eq!(simplify(lit(1).not_eq(lit(true))), lit(1).not_eq(lit(true)),);
-
-        assert_eq!(
-            simplify(lit("a").not_eq(lit(false))),
-            lit("a").not_eq(lit(false)),
+            simplify(col("c1").not_eq(lit("foo"))),
+            col("c1").not_eq(lit("foo")),
         );
     }
 
@@ -1303,15 +1296,15 @@ mod tests {
                 expr: None,
                 when_then_expr: vec![(
                     Box::new(col("c2").not_eq(lit(false))),
-                    Box::new(lit("ok").eq(lit(true))),
+                    Box::new(lit("ok").eq(lit("not_ok"))),
                 )],
                 else_expr: Some(Box::new(col("c2").eq(lit(true)))),
             }),
             Expr::Case {
                 expr: None,
                 when_then_expr: vec![(
                     Box::new(col("c2")),
-                    Box::new(lit("ok").eq(lit(true)))
+                    Box::new(lit(false))
                 )],
                 else_expr: Some(Box::new(col("c2"))),
             }