[GitHub] [calcite] Aaaaaaron commented on a change in pull request #2253: [CALCITE-4385] Extracts and eliminates/merges the condition that has common expressions (Jiatao Tao)

[GitBox]

Aaaaaaron commented on a change in pull request #2253:
URL: https://github.com/apache/calcite/pull/2253#discussion_r535278012



##########
File path: core/src/main/java/org/apache/calcite/rex/RexSimplify.java
##########
@@ -1698,6 +1699,113 @@ RexNode simplifyAnd2ForUnknownAsFalse(List<RexNode> 
terms,
     }
   }
 
+  /**
+   * <p>Simplifies AND/OR condition that has common expressions,
+   * extracts and eliminates/merges them as much as possible.</p>
+   * <ul>
+   * <li>(a OR b) AND (a OR b OR c OR d) =&gt; (a OR b)
+   * <li>(a OR b OR c OR d) AND (a OR b OR e OR f) =&gt; (a OR b) OR ((c OR d) 
AND (e OR f))
+
+   * <li>(a AND b) OR (a AND b AND c) =&gt; (a AND b)
+   * <li>(a AND b AND c AND d) OR (a AND b AND e AND f) =&gt;
+   * (a AND b) AND ((c AND d) OR (e AND f))
+   * </ul>
+   * <p> The difference between {@link #simplifyAnd} is that {@link 
#simplifyAnd} mainly
+   * simplifies expressions whose answer can be determined without evaluating 
both sides,
+   * like: FALSE AND (xxx) =&gt; FALSE</p>
+   */
+  public RexNode eliminateCommonExprInCondition(RexNode node) {
+    if (!(node instanceof RexCall)) {
+      return node;
+    }
+    // Simplify children recursively
+    // so that when we simplify parent node
+    // the child node should be simplified
+    List<RexNode> operands = ((RexCall) node).getOperands();
+    List<RexNode> simplifiedChildren = operands.stream()
+        .map(this::eliminateCommonExprInCondition)
+        .collect(Collectors.toList());
+
+    switch (node.getKind()) {
+    case AND: {
+      // Split the children to get the disjunctive predicates.
+      List<List<RexNode>> disjunctions = simplifiedChildren.stream()
+          .map(RelOptUtil::disjunctions)
+          .collect(Collectors.toList());
+
+      // Find the common predict among the list by retainAll.
+      List<RexNode> common = new ArrayList<>(disjunctions.get(0));
+      disjunctions.forEach(common::retainAll);

Review comment:
       Yes, but here I want to get the common part among the disjunctive 
conditions, seems there's no other good way, the good news is this operate 
expected to converge very quickly. Do you have any better solution, really 
thanks if you have a better way.




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org