[CALCITE-3916] Support top-down rule applying and upper bound space p…

…runing

Close apache#1991

core/src/main/java/org/apache/calcite/interpreter/BindableConvention.java

@@ -22,6 +22,7 @@
 import org.apache.calcite.plan.RelTrait;
 import org.apache.calcite.plan.RelTraitDef;
 import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
 
 /**
  * Calling convention that returns results as an
@@ -51,6 +52,10 @@ public String getName() {
     return "BINDABLE";
   }
 
+  @Override public RelNode enforce(RelNode input, RelTraitSet required) {
+    return null;
+  }
+
   public RelTraitDef getTraitDef() {
     return ConventionTraitDef.INSTANCE;
   }

core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java

@@ -47,7 +47,7 @@ public class RelOptRuleOperand {
   public int[] solveOrder;
   public int ordinalInParent;
   public int ordinalInRule;
-  private final RelTrait trait;
+  public final RelTrait trait;
   private final Class<? extends RelNode> clazz;
   private final ImmutableList<RelOptRuleOperand> children;
 

core/src/main/java/org/apache/calcite/plan/volcano/IterativeRuleDriver.java

@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.plan.volcano;
+
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.util.trace.CalciteTrace;
+
+import org.slf4j.Logger;
+
+/***
+ * <p>The algorithm executes repeatedly in a series of phases. In each phase
+ * the exact rules that may be fired varies. The mapping of phases to rule
+ * sets is maintained in the {@link #ruleQueue}.
+ *
+ * <p>In each phase, the planner then iterates over the rule matches presented
+ * by the rule queue until the rule queue becomes empty.
+ */
+class IterativeRuleDriver implements RuleDriver {
+
+  private static final Logger LOGGER = CalciteTrace.getPlannerTracer();
+
+  private final VolcanoPlanner planner;
+  private final IterativeRuleQueue ruleQueue;
+
+  IterativeRuleDriver(VolcanoPlanner planner) {
+    this.planner = planner;
+    ruleQueue = new IterativeRuleQueue(planner);
+  }
+
+  @Override public IterativeRuleQueue getRuleQueue() {
+    return ruleQueue;
+  }
+
+  @Override public void drive() {
+    PLANNING:
+    for (VolcanoPlannerPhase phase : VolcanoPlannerPhase.values()) {
+      while (true) {
+        LOGGER.debug("PLANNER = {}; PHASE = {}; COST = {}",
+            this, phase.toString(), planner.root.bestCost);
+
+        VolcanoRuleMatch match = ruleQueue.popMatch(phase);
+        if (match == null) {
+          break;
+        }
+
+        assert match.getRule().matches(match);
+        try {
+          match.onMatch();
+        } catch (VolcanoTimeoutException e) {
+          LOGGER.warn("Volcano planning times out, cancels the subsequent optimization.");
+          planner.canonize();
+          ruleQueue.phaseCompleted(phase);
+          break PLANNING;
+        }
+
+        // The root may have been merged with another
+        // subset. Find the new root subset.
+        planner.canonize();
+      }
+
+      ruleQueue.phaseCompleted(phase);
+    }
+  }
+
+  @Override public void onProduce(RelNode rel, RelSubset subset) {
+  }
+
+  @Override public void onSetMerged(RelSet set) {
+  }
+
+  @Override public void clear() {
+    ruleQueue.clear();
+  }
+}