CALCITE-1695 add RexExecutor to RexBuilder and remove optional argumen…

core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java

@@ -461,13 +461,8 @@ protected static boolean reduceExpressions(RelNode rel, List<RexNode> expList,
 
     boolean reduced = reduceExpressionsInternal(rel, expList, predicates);
 
-    // Simplify predicates in place
-    RexExecutor executor = rel.getCluster().getPlanner().getExecutor();
-    if (executor == null) {
-      executor = RexUtil.EXECUTOR;
-    }
     ExprSimplifier simplifier =
-        new ExprSimplifier(rexBuilder, unknownAsFalse, executor);
+        new ExprSimplifier(rexBuilder, unknownAsFalse);
     boolean simplified = false;
     for (int i = 0; i < expList.size(); i++) {
       RexNode expr2 = simplifier.apply(expList.get(i));

core/src/main/java/org/apache/calcite/rex/RexBuilder.java

@@ -91,6 +91,7 @@ public RexInputRef apply(RelDataTypeField input) {
   private final RexLiteral charEmpty;
   private final RexLiteral constantNull;
   private final SqlStdOperatorTable opTab = SqlStdOperatorTable.instance();
+  private RexExecutor executor;
 
   //~ Constructors -----------------------------------------------------------
 
@@ -123,6 +124,23 @@ public RexBuilder(RelDataTypeFactory typeFactory) {
             SqlTypeName.NULL);
   }
 
+  /**
+   * Gets the RexExecutor carried by this builder
+   * @return the executor
+   */
+  public RexExecutor getExecutor() {
+    return executor;
+  }
+
+  /**
+   * Sets the RexExecutor carried by this builder.
+   * The executor is used in RexUtil.simplifyXxx for evaluating constants
+   * @param executor the executor
+   */
+  public void setExecutor(RexExecutor executor) {
+    this.executor = executor;
+  }
+
   /** Creates a list of {@link org.apache.calcite.rex.RexInputRef} expressions,
    * projecting the fields of a given record type. */
   public List<? extends RexNode> identityProjects(final RelDataType rowType) {

core/src/main/java/org/apache/calcite/rex/RexUtil.java

@@ -1567,8 +1567,8 @@ public static boolean eq(RexNode e1, RexNode e2) {
    * <p>This is useful if you are simplifying expressions in a
    * {@link Project}. */
   public static RexNode simplifyPreservingType(RexBuilder rexBuilder,
-      RexNode e, RexExecutor executor) {
-    final RexNode e2 = simplify(rexBuilder, e, false, executor);
+    RexNode e) {
+    final RexNode e2 = simplify(rexBuilder, e, false);
     if (e2.getType() == e.getType()) {
       return e2;
     }
@@ -1584,16 +1584,7 @@ public static RexNode simplifyPreservingType(RexBuilder rexBuilder,
    * using the default executor.
    */
   public static RexNode simplify(RexBuilder rexBuilder, RexNode e) {
-    return simplify(rexBuilder, e, false, EXECUTOR);
-  }
-
-  /**
-   * Simplifies a boolean expression,
-   * using the default executor.
-   */
-  public static RexNode simplify(RexBuilder rexBuilder, RexNode e,
-      boolean unknownAsFalse) {
-    return simplify(rexBuilder, e, unknownAsFalse, EXECUTOR);
+    return simplify(rexBuilder, e, false);
   }
 
   /**
@@ -1615,11 +1606,9 @@ public static RexNode simplify(RexBuilder rexBuilder, RexNode e,
    * @param rexBuilder Rex builder
    * @param e Expression to simplify
    * @param unknownAsFalse Whether to convert UNKNOWN values to FALSE
-   * @param executor Executor for constant reduction, not null
    */
   public static RexNode simplify(RexBuilder rexBuilder, RexNode e,
-      boolean unknownAsFalse, RexExecutor executor) {
-    Preconditions.checkNotNull(executor);
+      boolean unknownAsFalse) {
     switch (e.getKind()) {
     case AND:
       return simplifyAnd(rexBuilder, (RexCall) e, unknownAsFalse);
@@ -1630,7 +1619,7 @@ public static RexNode simplify(RexBuilder rexBuilder, RexNode e,
     case CASE:
       return simplifyCase(rexBuilder, (RexCall) e, unknownAsFalse);
     case CAST:
-      return simplifyCast(rexBuilder, (RexCall) e, executor);
+      return simplifyCast(rexBuilder, (RexCall) e);
     case IS_NULL:
     case IS_NOT_NULL:
     case IS_TRUE:
@@ -2115,7 +2104,6 @@ public static RexNode simplifyAnd2(RexBuilder rexBuilder,
    * UNKNOWN it will be interpreted as FALSE. */
   public static RexNode simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder,
       List<RexNode> terms, List<RexNode> notTerms) {
-    final RexExecutor executor = EXECUTOR;
     for (RexNode term : terms) {
       if (term.isAlwaysFalse()) {
         return rexBuilder.makeLiteral(false);
@@ -2287,7 +2275,7 @@ public static RexNode simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder,
     for (RexNode notDisjunction : notTerms) {
       final RexNode call =
           rexBuilder.makeCall(SqlStdOperatorTable.NOT, notDisjunction);
-      terms.add(simplify(rexBuilder, call, true, executor));
+      terms.add(simplify(rexBuilder, call, true));
     }
     // The negated terms: only deterministic expressions
     for (String negatedTerm : negatedTerms) {
@@ -2420,9 +2408,7 @@ public static boolean isCasePredicate(RexCall call, int i) {
         && (call.operands.size() - i) % 2 == 1;
   }
 
-  private static RexNode simplifyCast(RexBuilder rexBuilder, RexCall e,
-      RexExecutor executor) {
-    Preconditions.checkNotNull(executor);
+  private static RexNode simplifyCast(RexBuilder rexBuilder, RexCall e) {
     final RexNode operand = e.getOperands().get(0);
     switch (operand.getKind()) {
     case LITERAL:
@@ -2447,6 +2433,11 @@ private static RexNode simplifyCast(RexBuilder rexBuilder, RexCall e,
         }
       }
       final List<RexNode> reducedValues = new ArrayList<>();
+
+      // The rexBuilder may carry a custom executor that has to be used
+      // instead of the default one
+      final RexExecutor executor = Util.first(
+        rexBuilder.getExecutor(), EXECUTOR);
       executor.reduce(rexBuilder, ImmutableList.<RexNode>of(e), reducedValues);
       return Preconditions.checkNotNull(
           Iterables.getOnlyElement(reducedValues));
@@ -3015,14 +3006,11 @@ public static RexSubQuery find(RexNode node) {
   /** Deep expressions simplifier. */
   public static class ExprSimplifier extends RexShuttle {
     private final RexBuilder rexBuilder;
-    private final RexExecutor executor;
     private final boolean unknownAsFalse;
     private final Map<RexNode, Boolean> unknownAsFalseMap;
 
-    public ExprSimplifier(RexBuilder rexBuilder, boolean unknownAsFalse,
-        RexExecutor executor) {
+    public ExprSimplifier(RexBuilder rexBuilder, boolean unknownAsFalse) {
       this.rexBuilder = Preconditions.checkNotNull(rexBuilder);
-      this.executor = Preconditions.checkNotNull(executor);
       this.unknownAsFalse = unknownAsFalse;
       this.unknownAsFalseMap = new HashMap<>();
     }
@@ -3048,7 +3036,7 @@ public ExprSimplifier(RexBuilder rexBuilder, boolean unknownAsFalse,
       }
       RexNode node = super.visitCall(call);
       RexNode simplifiedNode =
-          simplify(rexBuilder, node, unknownAsFalseCall, executor);
+          simplify(rexBuilder, node, unknownAsFalseCall);
       if (node == simplifiedNode) {
         return node;
       }

core/src/main/java/org/apache/calcite/tools/RelBuilder.java

@@ -133,7 +133,6 @@ public String apply(RexNode input) {
   private final RelFactories.TableScanFactory scanFactory;
   private final Deque<Frame> stack = new ArrayDeque<>();
   private final boolean simplify;
-  private final RexExecutor executor;
 
   protected RelBuilder(Context context, RelOptCluster cluster,
       RelOptSchema relOptSchema) {
@@ -173,9 +172,9 @@ protected RelBuilder(Context context, RelOptCluster cluster,
     this.scanFactory =
         Util.first(context.unwrap(RelFactories.TableScanFactory.class),
             RelFactories.DEFAULT_TABLE_SCAN_FACTORY);
-    this.executor =
+    this.getRexBuilder().setExecutor(
         Util.first(context.unwrap(RexExecutor.class),
-            Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR));
+            Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR)));
   }
 
   /** Creates a RelBuilder. */
@@ -870,7 +869,7 @@ public RelBuilder project(
     final Iterator<String> nameIterator = fieldNames.iterator();
     for (RexNode node : nodes) {
       if (simplify) {
-        node = RexUtil.simplifyPreservingType(getRexBuilder(), node, executor);
+        node = RexUtil.simplifyPreservingType(getRexBuilder(), node);
       }
       exprList.add(node);
       String name = nameIterator.hasNext() ? nameIterator.next() : null;