moar

Author: alamb

datafusion/src/optimizer/simplify_expressions.rs

@@ -45,6 +45,8 @@ use crate::{error::Result, logical_plan::Operator};
 ///
 pub struct SimplifyExpressions {}
 
+/// returns true if `needle` is found in a chain of AND/OR exprs
+/// (A AND B) AND C
 fn expr_contains(expr: &Expr, needle: &Expr) -> bool {
     match expr {
         Expr::BinaryExpr {
@@ -61,7 +63,7 @@ fn expr_contains(expr: &Expr, needle: &Expr) -> bool {
     }
 }
 
-fn as_binary_expr(expr: &Expr) -> Option<&Expr> {
+fn as_binary_expr_old(expr: &Expr) -> Option<&Expr> {
     match expr {
         Expr::BinaryExpr { .. } => Some(expr),
         _ => None,
@@ -185,7 +187,7 @@ fn old_simplify(expr: &Expr) -> Expr {
             left,
             op: Operator::Or,
             right,
-        } if expr_contains(left, right) => as_binary_expr(left)
+        } if expr_contains(left, right) => as_binary_expr_old(left)
             .map(|x| match x {
                 Expr::BinaryExpr {
                     left: _,
@@ -204,7 +206,7 @@ fn old_simplify(expr: &Expr) -> Expr {
             left,
             op: Operator::Or,
             right,
-        } if expr_contains(right, left) => as_binary_expr(right)
+        } if expr_contains(right, left) => as_binary_expr_old(right)
             .map(|x| match x {
                 Expr::BinaryExpr {
                     left: _,
@@ -223,7 +225,7 @@ fn old_simplify(expr: &Expr) -> Expr {
             left,
             op: Operator::And,
             right,
-        } if expr_contains(left, right) => as_binary_expr(left)
+        } if expr_contains(left, right) => as_binary_expr_old(left)
             .map(|x| match x {
                 Expr::BinaryExpr {
                     left: _,
@@ -242,7 +244,7 @@ fn old_simplify(expr: &Expr) -> Expr {
             left,
             op: Operator::And,
             right,
-        } if expr_contains(right, left) => as_binary_expr(right)
+        } if expr_contains(right, left) => as_binary_expr_old(right)
             .map(|x| match x {
                 Expr::BinaryExpr {
                     left: _,
@@ -695,7 +697,7 @@ impl<'a> ExprRewriter for Simplifier<'a> {
                     }
                     (left, Literal(Boolean(b))) if self.is_boolean_type(&left) => {
                         Self::boolean_folding_for_or(b, left, false)
-                    },
+                    }
                     // A OR A --> A
                     (left, right) if left == right => left,
                     (left, right) => BinaryExpr {
@@ -724,8 +726,6 @@ impl<'a> ExprRewriter for Simplifier<'a> {
                 Operator::Divide if is_one(&right) => *left,
                 Operator::Divide if left == right && is_null(&left) => *left,
                 Operator::Divide if left == right => lit(1),
-
-
                 _ => BinaryExpr { left, op, right },
             },
             // Not(Not(expr)) --> expr