update test case

Author: gengliangwang

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/predicates.scala

@@ -208,43 +208,48 @@ trait PredicateHelper extends Logging {
    */
   protected def convertibleFilter(
     condition: Expression,
-    outputSet: AttributeSet): Option[Expression] = condition match {
-    case And(left, right) =>
-      val leftResultOptional = convertibleFilter(left, outputSet)
-      val rightResultOptional = convertibleFilter(right, outputSet)
-      (leftResultOptional, rightResultOptional) match {
-        case (Some(leftResult), Some(rightResult)) => Some(And(leftResult, rightResult))
-        case (Some(leftResult), None) => Some(leftResult)
-        case (None, Some(rightResult)) => Some(rightResult)
-        case _ => None
-      }
+    outputSet: AttributeSet): Option[Expression] = {
+    println("condition: " + condition)
+    val ret = condition match {
+      case And(left, right) =>
+        val leftResultOptional = convertibleFilter(left, outputSet)
+        val rightResultOptional = convertibleFilter(right, outputSet)
+        (leftResultOptional, rightResultOptional) match {
+          case (Some(leftResult), Some(rightResult)) => Some(And(leftResult, rightResult))
+          case (Some(leftResult), None) => Some(leftResult)
+          case (None, Some(rightResult)) => Some(rightResult)
+          case _ => None
+        }
 
-    // The Or predicate is convertible when both of its children can be pushed down.
-    // That is to say, if one/both of the children can be partially pushed down, the Or
-    // predicate can be partially pushed down as well.
-    //
-    // Here is an example used to explain the reason.
-    // Let's say we have
-    // (a1 AND a2) OR (b1 AND b2),
-    // a1 and b1 is convertible, while a2 and b2 is not.
-    // The predicate can be converted as
-    // (a1 OR b1) AND (a1 OR b2) AND (a2 OR b1) AND (a2 OR b2)
-    // As per the logical in And predicate, we can push down (a1 OR b1).
-    case Or(left, right) =>
-      for {
-        lhs <- convertibleFilter(left, outputSet)
-        rhs <- convertibleFilter(right, outputSet)
-      } yield Or(lhs, rhs)
-
-    // Here we assume all the `Not` operators is already below all the `And` and `Or` operators
-    // after the optimization rule `BooleanSimplification`, so that we don't need to handle the
-    // `Not` operators here.
-    case other =>
-      if (other.references.subsetOf(outputSet)) {
-        Some(other)
-      } else {
-        None
-      }
+      // The Or predicate is convertible when both of its children can be pushed down.
+      // That is to say, if one/both of the children can be partially pushed down, the Or
+      // predicate can be partially pushed down as well.
+      //
+      // Here is an example used to explain the reason.
+      // Let's say we have
+      // (a1 AND a2) OR (b1 AND b2),
+      // a1 and b1 is convertible, while a2 and b2 is not.
+      // The predicate can be converted as
+      // (a1 OR b1) AND (a1 OR b2) AND (a2 OR b1) AND (a2 OR b2)
+      // As per the logical in And predicate, we can push down (a1 OR b1).
+      case Or(left, right) =>
+        for {
+          lhs <- convertibleFilter(left, outputSet)
+          rhs <- convertibleFilter(right, outputSet)
+        } yield Or(lhs, rhs)
+
+      // Here we assume all the `Not` operators is already below all the `And` and `Or` operators
+      // after the optimization rule `BooleanSimplification`, so that we don't need to handle the
+      // `Not` operators here.
+      case other =>
+        if (other.references.subsetOf(outputSet)) {
+          Some(other)
+        } else {
+          None
+        }
+    }
+    println("ret: " + ret)
+    ret
   }
 }
 

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/ConvertibleFilterSuite.scala

@@ -73,7 +73,7 @@ class ConvertibleFilterSuite extends SparkFunSuite with PredicateHelper with Pla
     checkCondition((a || b) || (c && d) || (e && f) || (g && h), Seq(a, c, e, g), None)
     checkCondition((a || b) || (c && d) || (e && f) || (g && h), Seq(a, b, c, e, g),
       Some(a || b || c || e || g))
-    checkCondition((a || b || c) && (d || e || f) || (g || h || i), Seq(b, e, h), Some(b || e || h))
-    checkCondition((a || b || c) && (d || e || f) || (g || h || i), Seq(b, e, d), None)
+    checkCondition((a && b && c) || (d && e && f) || (g && h && i), Seq(b, e, h), Some(b || e || h))
+    checkCondition((a && b && c) || (d && e && f) || (g && h && i), Seq(b, e, d), None)
   }
 }