calcite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jh...@apache.org
Subject [14/50] [abbrv] calcite git commit: [CALCITE-794] Detect cycles when computing statistics
Date Sat, 23 Jan 2016 00:30:32 GMT
http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
index d77ca13..cb1de64 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
@@ -54,20 +54,23 @@ public class RelMdUniqueKeys {
 
   //~ Methods ----------------------------------------------------------------
 
-  public Set<ImmutableBitSet> getUniqueKeys(Filter rel, boolean ignoreNulls) {
-    return RelMetadataQuery.getUniqueKeys(rel.getInput(), ignoreNulls);
+  public Set<ImmutableBitSet> getUniqueKeys(Filter rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
+    return mq.getUniqueKeys(rel.getInput(), ignoreNulls);
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(Sort rel, boolean ignoreNulls) {
-    return RelMetadataQuery.getUniqueKeys(rel.getInput(), ignoreNulls);
+  public Set<ImmutableBitSet> getUniqueKeys(Sort rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
+    return mq.getUniqueKeys(rel.getInput(), ignoreNulls);
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(Correlate rel,
+  public Set<ImmutableBitSet> getUniqueKeys(Correlate rel, RelMetadataQuery mq,
       boolean ignoreNulls) {
-    return RelMetadataQuery.getUniqueKeys(rel.getLeft(), ignoreNulls);
+    return mq.getUniqueKeys(rel.getLeft(), ignoreNulls);
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(Project rel, boolean ignoreNulls) {
+  public Set<ImmutableBitSet> getUniqueKeys(Project rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
     // LogicalProject maps a set of rows to a different set;
     // Without knowledge of the mapping function(whether it
     // preserves uniqueness), it is only safe to derive uniqueness
@@ -75,11 +78,9 @@ public class RelMdUniqueKeys {
     //
     // Further more, the unique bitset coming from the child needs
     // to be mapped to match the output of the project.
-    Map<Integer, Integer> mapInToOutPos = new HashMap<>();
-
-    List<RexNode> projExprs = rel.getProjects();
-
-    Set<ImmutableBitSet> projUniqueKeySet = new HashSet<>();
+    final Map<Integer, Integer> mapInToOutPos = new HashMap<>();
+    final List<RexNode> projExprs = rel.getProjects();
+    final Set<ImmutableBitSet> projUniqueKeySet = new HashSet<>();
 
     // Build an input to output position map.
     for (int i = 0; i < projExprs.size(); i++) {
@@ -96,7 +97,7 @@ public class RelMdUniqueKeys {
     }
 
     Set<ImmutableBitSet> childUniqueKeySet =
-        RelMetadataQuery.getUniqueKeys(rel.getInput(), ignoreNulls);
+        mq.getUniqueKeys(rel.getInput(), ignoreNulls);
 
     if (childUniqueKeySet != null) {
       // Now add to the projUniqueKeySet the child keys that are fully
@@ -123,7 +124,8 @@ public class RelMdUniqueKeys {
     return projUniqueKeySet;
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(Join rel, boolean ignoreNulls) {
+  public Set<ImmutableBitSet> getUniqueKeys(Join rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
     final RelNode left = rel.getLeft();
     final RelNode right = rel.getRight();
 
@@ -136,13 +138,11 @@ public class RelMdUniqueKeys {
     // that is undesirable, use RelMetadataQuery.areColumnsUnique() as
     // an alternative way of getting unique key information.
 
-    Set<ImmutableBitSet> retSet = new HashSet<>();
-    Set<ImmutableBitSet> leftSet =
-        RelMetadataQuery.getUniqueKeys(left, ignoreNulls);
+    final Set<ImmutableBitSet> retSet = new HashSet<>();
+    final Set<ImmutableBitSet> leftSet = mq.getUniqueKeys(left, ignoreNulls);
     Set<ImmutableBitSet> rightSet = null;
 
-    Set<ImmutableBitSet> tmpRightSet =
-        RelMetadataQuery.getUniqueKeys(right, ignoreNulls);
+    final Set<ImmutableBitSet> tmpRightSet = mq.getUniqueKeys(right, ignoreNulls);
     int nFieldsOnLeft = left.getRowType().getFieldCount();
 
     if (tmpRightSet != null) {
@@ -169,12 +169,10 @@ public class RelMdUniqueKeys {
 
     // determine if either or both the LHS and RHS are unique on the
     // equijoin columns
-    Boolean leftUnique =
-        RelMetadataQuery.areColumnsUnique(left, joinInfo.leftSet(),
-            ignoreNulls);
-    Boolean rightUnique =
-        RelMetadataQuery.areColumnsUnique(right, joinInfo.rightSet(),
-            ignoreNulls);
+    final Boolean leftUnique =
+        mq.areColumnsUnique(left, joinInfo.leftSet(), ignoreNulls);
+    final Boolean rightUnique =
+        mq.areColumnsUnique(right, joinInfo.rightSet(), ignoreNulls);
 
     // if the right hand side is unique on its equijoin columns, then we can
     // add the unique keys from left if the left hand side is not null
@@ -197,19 +195,20 @@ public class RelMdUniqueKeys {
     return retSet;
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(SemiJoin rel, boolean ignoreNulls) {
+  public Set<ImmutableBitSet> getUniqueKeys(SemiJoin rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
     // only return the unique keys from the LHS since a semijoin only
     // returns the LHS
-    return RelMetadataQuery.getUniqueKeys(rel.getLeft(), ignoreNulls);
+    return mq.getUniqueKeys(rel.getLeft(), ignoreNulls);
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(Aggregate rel,
+  public Set<ImmutableBitSet> getUniqueKeys(Aggregate rel, RelMetadataQuery mq,
       boolean ignoreNulls) {
     // group by keys form a unique key
     return ImmutableSet.of(rel.getGroupSet());
   }
 
-  public Set<ImmutableBitSet> getUniqueKeys(SetOp rel,
+  public Set<ImmutableBitSet> getUniqueKeys(SetOp rel, RelMetadataQuery mq,
       boolean ignoreNulls) {
     if (!rel.all) {
       return ImmutableSet.of(
@@ -219,7 +218,8 @@ public class RelMdUniqueKeys {
   }
 
   // Catch-all rule when none of the others apply.
-  public Set<ImmutableBitSet> getUniqueKeys(RelNode rel, boolean ignoreNulls) {
+  public Set<ImmutableBitSet> getUniqueKeys(RelNode rel, RelMetadataQuery mq,
+      boolean ignoreNulls) {
     // no information available
     return null;
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
index dc1ea3e..5435979 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
@@ -26,11 +26,14 @@ import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.rel.core.Minus;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.SemiJoin;
+import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexLocalRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexProgram;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexVisitorImpl;
 import org.apache.calcite.sql.SqlFunction;
@@ -77,13 +80,11 @@ public class RelMdUtil {
    * @param rel the semijoin of interest
    * @return constructed rexnode
    */
-  public static RexNode makeSemiJoinSelectivityRexNode(SemiJoin rel) {
+  public static RexNode makeSemiJoinSelectivityRexNode(RelMetadataQuery mq,
+      SemiJoin rel) {
     RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
     double selectivity =
-        computeSemiJoinSelectivity(
-            rel.getLeft(),
-            rel.getRight(),
-            rel);
+        computeSemiJoinSelectivity(mq, rel.getLeft(), rel.getRight(), rel);
     RexNode selec =
         rexBuilder.makeApproxLiteral(new BigDecimal(selectivity));
     return rexBuilder.makeCall(ARTIFICIAL_SELECTIVITY_FUNC, selec);
@@ -113,12 +114,10 @@ public class RelMdUtil {
    * @param rel semijoin rel
    * @return calculated selectivity
    */
-  public static double computeSemiJoinSelectivity(SemiJoin rel) {
-    return computeSemiJoinSelectivity(
-        rel.getLeft(),
-        rel.getRight(),
-        rel.getLeftKeys(),
-        rel.getRightKeys());
+  public static double computeSemiJoinSelectivity(RelMetadataQuery mq,
+      SemiJoin rel) {
+    return computeSemiJoinSelectivity(mq, rel.getLeft(), rel.getRight(),
+        rel.getLeftKeys(), rel.getRightKeys());
   }
 
   /**
@@ -132,14 +131,9 @@ public class RelMdUtil {
    * @param rel     semijoin rel
    * @return calculated selectivity
    */
-  public static double computeSemiJoinSelectivity(
-      RelNode factRel,
-      RelNode dimRel,
-      SemiJoin rel) {
-    return computeSemiJoinSelectivity(
-        factRel,
-        dimRel,
-        rel.getLeftKeys(),
+  public static double computeSemiJoinSelectivity(RelMetadataQuery mq,
+      RelNode factRel, RelNode dimRel, SemiJoin rel) {
+    return computeSemiJoinSelectivity(mq, factRel, dimRel, rel.getLeftKeys(),
         rel.getRightKeys());
   }
 
@@ -155,10 +149,8 @@ public class RelMdUtil {
    * @param dimKeyList  RHS keys used in the filter
    * @return calculated selectivity
    */
-  public static double computeSemiJoinSelectivity(
-      RelNode factRel,
-      RelNode dimRel,
-      List<Integer> factKeyList,
+  public static double computeSemiJoinSelectivity(RelMetadataQuery mq,
+      RelNode factRel, RelNode dimRel, List<Integer> factKeyList,
       List<Integer> dimKeyList) {
     ImmutableBitSet.Builder factKeys = ImmutableBitSet.builder();
     for (int factCol : factKeyList) {
@@ -170,20 +162,19 @@ public class RelMdUtil {
     }
     final ImmutableBitSet dimKeys = dimKeyBuilder.build();
 
-    Double factPop =
-        RelMetadataQuery.getPopulationSize(factRel, factKeys.build());
+    Double factPop = mq.getPopulationSize(factRel, factKeys.build());
     if (factPop == null) {
       // use the dimension population if the fact population is
       // unavailable; since we're filtering the fact table, that's
       // the population we ideally want to use
-      factPop = RelMetadataQuery.getPopulationSize(dimRel, dimKeys);
+      factPop = mq.getPopulationSize(dimRel, dimKeys);
     }
 
     // if cardinality and population are available, use them; otherwise
     // use percentage original rows
     Double selectivity;
     Double dimCard =
-        RelMetadataQuery.getDistinctRowCount(
+        mq.getDistinctRowCount(
             dimRel,
             dimKeys,
             null);
@@ -194,7 +185,7 @@ public class RelMdUtil {
       }
       selectivity = dimCard / factPop;
     } else {
-      selectivity = RelMetadataQuery.getPercentageOriginalRows(dimRel);
+      selectivity = mq.getPercentageOriginalRows(dimRel);
     }
 
     if (selectivity == null) {
@@ -220,26 +211,24 @@ public class RelMdUtil {
    * @return true if bit mask represents a unique column set; false if not (or
    * if no metadata is available)
    */
-  public static boolean areColumnsDefinitelyUnique(
-      RelNode rel,
-      ImmutableBitSet colMask) {
-    Boolean b = RelMetadataQuery.areColumnsUnique(rel, colMask, false);
+  public static boolean areColumnsDefinitelyUnique(RelMetadataQuery mq,
+      RelNode rel, ImmutableBitSet colMask) {
+    Boolean b = mq.areColumnsUnique(rel, colMask, false);
     return b != null && b;
   }
 
-  public static Boolean areColumnsUnique(
-      RelNode rel,
+  public static Boolean areColumnsUnique(RelMetadataQuery mq, RelNode rel,
       List<RexInputRef> columnRefs) {
     ImmutableBitSet.Builder colMask = ImmutableBitSet.builder();
     for (RexInputRef columnRef : columnRefs) {
       colMask.set(columnRef.getIndex());
     }
-    return RelMetadataQuery.areColumnsUnique(rel, colMask.build());
+    return mq.areColumnsUnique(rel, colMask.build());
   }
 
-  public static boolean areColumnsDefinitelyUnique(RelNode rel,
-      List<RexInputRef> columnRefs) {
-    Boolean b = areColumnsUnique(rel, columnRefs);
+  public static boolean areColumnsDefinitelyUnique(RelMetadataQuery mq,
+      RelNode rel, List<RexInputRef> columnRefs) {
+    Boolean b = areColumnsUnique(mq, rel, columnRefs);
     return b != null && b;
   }
 
@@ -255,31 +244,29 @@ public class RelMdUtil {
    * @return true if bit mask represents a unique column set; false if not (or
    * if no metadata is available)
    */
-  public static boolean areColumnsDefinitelyUniqueWhenNullsFiltered(RelNode rel,
-      ImmutableBitSet colMask) {
-    Boolean b = RelMetadataQuery.areColumnsUnique(rel, colMask, true);
+  public static boolean areColumnsDefinitelyUniqueWhenNullsFiltered(
+      RelMetadataQuery mq, RelNode rel, ImmutableBitSet colMask) {
+    Boolean b = mq.areColumnsUnique(rel, colMask, true);
     if (b == null) {
       return false;
     }
     return b;
   }
 
-  public static Boolean areColumnsUniqueWhenNullsFiltered(
-      RelNode rel,
-      List<RexInputRef> columnRefs) {
+  public static Boolean areColumnsUniqueWhenNullsFiltered(RelMetadataQuery mq,
+      RelNode rel, List<RexInputRef> columnRefs) {
     ImmutableBitSet.Builder colMask = ImmutableBitSet.builder();
 
     for (RexInputRef columnRef : columnRefs) {
       colMask.set(columnRef.getIndex());
     }
 
-    return RelMetadataQuery.areColumnsUnique(rel, colMask.build(), true);
+    return mq.areColumnsUnique(rel, colMask.build(), true);
   }
 
   public static boolean areColumnsDefinitelyUniqueWhenNullsFiltered(
-      RelNode rel,
-      List<RexInputRef> columnRefs) {
-    Boolean b = areColumnsUniqueWhenNullsFiltered(rel, columnRefs);
+      RelMetadataQuery mq, RelNode rel, List<RexInputRef> columnRefs) {
+    Boolean b = areColumnsUniqueWhenNullsFiltered(mq, rel, columnRefs);
     if (b == null) {
       return false;
     }
@@ -476,9 +463,9 @@ public class RelMdUtil {
       RexBuilder rexBuilder,
       RexNode pred1,
       RexNode pred2) {
-    List<RexNode> list1 = RelOptUtil.conjunctions(pred1);
-    List<RexNode> list2 = RelOptUtil.conjunctions(pred2);
-    List<RexNode> minusList = new ArrayList<>();
+    final List<RexNode> list1 = RelOptUtil.conjunctions(pred1);
+    final List<RexNode> list2 = RelOptUtil.conjunctions(pred2);
+    final List<RexNode> minusList = new ArrayList<>();
 
     for (RexNode rex1 : list1) {
       boolean add = true;
@@ -550,14 +537,15 @@ public class RelMdUtil {
 
   /**
    * Computes the cardinality of a particular expression from the projection
-   * list
+   * list.
    *
    * @param rel  RelNode corresponding to the project
    * @param expr projection expression
    * @return cardinality
    */
-  public static Double cardOfProjExpr(Project rel, RexNode expr) {
-    return expr.accept(new CardOfProjExpr(rel));
+  public static Double cardOfProjExpr(RelMetadataQuery mq, Project rel,
+      RexNode expr) {
+    return expr.accept(new CardOfProjExpr(mq, rel));
   }
 
   /**
@@ -567,9 +555,8 @@ public class RelMdUtil {
    * @param groupKey keys to compute the population for
    * @return computed population size
    */
-  public static Double getJoinPopulationSize(
-      RelNode joinRel,
-      ImmutableBitSet groupKey) {
+  public static Double getJoinPopulationSize(RelMetadataQuery mq,
+      RelNode joinRel, ImmutableBitSet groupKey) {
     ImmutableBitSet.Builder leftMask = ImmutableBitSet.builder();
     ImmutableBitSet.Builder rightMask = ImmutableBitSet.builder();
     RelNode left = joinRel.getInputs().get(0);
@@ -577,23 +564,14 @@ public class RelMdUtil {
 
     // separate the mask into masks for the left and right
     RelMdUtil.setLeftRightBitmaps(
-        groupKey,
-        leftMask,
-        rightMask,
-        left.getRowType().getFieldCount());
+        groupKey, leftMask, rightMask, left.getRowType().getFieldCount());
 
     Double population =
         NumberUtil.multiply(
-            RelMetadataQuery.getPopulationSize(
-                left,
-                leftMask.build()),
-            RelMetadataQuery.getPopulationSize(
-                right,
-                rightMask.build()));
+            mq.getPopulationSize(left, leftMask.build()),
+            mq.getPopulationSize(right, rightMask.build()));
 
-    return RelMdUtil.numDistinctVals(
-        population,
-        RelMetadataQuery.getRowCount(joinRel));
+    return numDistinctVals(population, mq.getRowCount(joinRel));
   }
 
   /**
@@ -608,12 +586,9 @@ public class RelMdUtil {
    *                  otherwise use <code>left NDV * right NDV</code>.
    * @return number of distinct rows
    */
-  public static Double getJoinDistinctRowCount(
-      RelNode joinRel,
-      JoinRelType joinType,
-      ImmutableBitSet groupKey,
-      RexNode predicate,
-      boolean useMaxNdv) {
+  public static Double getJoinDistinctRowCount(RelMetadataQuery mq,
+      RelNode joinRel, JoinRelType joinType, ImmutableBitSet groupKey,
+      RexNode predicate, boolean useMaxNdv) {
     Double distRowCount;
     ImmutableBitSet.Builder leftMask = ImmutableBitSet.builder();
     ImmutableBitSet.Builder rightMask = ImmutableBitSet.builder();
@@ -630,10 +605,10 @@ public class RelMdUtil {
     RexNode leftPred = null;
     RexNode rightPred = null;
     if (predicate != null) {
-      List<RexNode> leftFilters = new ArrayList<>();
-      List<RexNode> rightFilters = new ArrayList<>();
-      List<RexNode> joinFilters = new ArrayList<>();
-      List<RexNode> predList = RelOptUtil.conjunctions(predicate);
+      final List<RexNode> leftFilters = new ArrayList<>();
+      final List<RexNode> rightFilters = new ArrayList<>();
+      final List<RexNode> joinFilters = new ArrayList<>();
+      final List<RexNode> predList = RelOptUtil.conjunctions(predicate);
 
       RelOptUtil.classifyFilters(
           joinRel,
@@ -655,35 +630,35 @@ public class RelMdUtil {
 
     if (useMaxNdv) {
       distRowCount = Math.max(
-          RelMetadataQuery.getDistinctRowCount(left, leftMask.build(),
-              leftPred),
-          RelMetadataQuery.getDistinctRowCount(right, rightMask.build(),
-              rightPred));
+          mq.getDistinctRowCount(left, leftMask.build(), leftPred),
+          mq.getDistinctRowCount(right, rightMask.build(), rightPred));
     } else {
       distRowCount =
         NumberUtil.multiply(
-            RelMetadataQuery.getDistinctRowCount(
-                left,
-                leftMask.build(),
-                leftPred),
-            RelMetadataQuery.getDistinctRowCount(
-                right,
-                rightMask.build(),
-                rightPred));
+            mq.getDistinctRowCount(left, leftMask.build(), leftPred),
+            mq.getDistinctRowCount(right, rightMask.build(), rightPred));
     }
 
-    return RelMdUtil.numDistinctVals(
-        distRowCount,
-        RelMetadataQuery.getRowCount(joinRel));
+    return RelMdUtil.numDistinctVals(distRowCount, mq.getRowCount(joinRel));
+  }
+
+  /** Returns an estimate of the number of rows returned by a {@link Union}
+   * (before duplicates are eliminated). */
+  public static double getUnionAllRowCount(RelMetadataQuery mq, Union rel) {
+    double rowCount = 0;
+    for (RelNode input : rel.getInputs()) {
+      rowCount += mq.getRowCount(input);
+    }
+    return rowCount;
   }
 
   /** Returns an estimate of the number of rows returned by a {@link Minus}. */
-  public static double getMinusRowCount(Minus minus) {
+  public static double getMinusRowCount(RelMetadataQuery mq, Minus minus) {
     // REVIEW jvs 30-May-2005:  I just pulled this out of a hat.
     final List<RelNode> inputs = minus.getInputs();
-    double dRows = RelMetadataQuery.getRowCount(inputs.get(0));
+    double dRows = mq.getRowCount(inputs.get(0));
     for (int i = 1; i < inputs.size(); i++) {
-      dRows -= 0.5 * RelMetadataQuery.getRowCount(inputs.get(i));
+      dRows -= 0.5 * mq.getRowCount(inputs.get(i));
     }
     if (dRows < 0) {
       dRows = 0;
@@ -692,16 +667,17 @@ public class RelMdUtil {
   }
 
   /** Returns an estimate of the number of rows returned by a {@link Join}. */
-  public static Double getJoinRowCount(Join join, RexNode condition) {
+  public static Double getJoinRowCount(RelMetadataQuery mq, Join join,
+      RexNode condition) {
     // Row count estimates of 0 will be rounded up to 1.
     // So, use maxRowCount where the product is very small.
-    final Double left = RelMetadataQuery.getRowCount(join.getLeft());
-    final Double right = RelMetadataQuery.getRowCount(join.getRight());
+    final Double left = mq.getRowCount(join.getLeft());
+    final Double right = mq.getRowCount(join.getRight());
     if (left == null || right == null) {
       return null;
     }
     if (left <= 1D || right <= 1D) {
-      Double max = RelMetadataQuery.getMaxRowCount(join);
+      Double max = mq.getMaxRowCount(join);
       if (max != null && max <= 1D) {
         return max;
       }
@@ -709,30 +685,51 @@ public class RelMdUtil {
     double product = left * right;
 
     // TODO:  correlation factor
-    return product * RelMetadataQuery.getSelectivity(join, condition);
+    return product * mq.getSelectivity(join, condition);
   }
 
   /** Returns an estimate of the number of rows returned by a
    * {@link SemiJoin}. */
-  public static Double getSemiJoinRowCount(RelNode left, RelNode right,
-      JoinRelType joinType, RexNode condition) {
+  public static Double getSemiJoinRowCount(RelMetadataQuery mq, RelNode left,
+      RelNode right, JoinRelType joinType, RexNode condition) {
     // TODO:  correlation factor
-    final Double leftCount = RelMetadataQuery.getRowCount(left);
+    final Double leftCount = mq.getRowCount(left);
     if (leftCount == null) {
       return null;
     }
     return leftCount * RexUtil.getSelectivity(condition);
   }
 
+  public static double estimateFilteredRows(RelNode child, RexProgram program,
+      RelMetadataQuery mq) {
+    // convert the program's RexLocalRef condition to an expanded RexNode
+    RexLocalRef programCondition = program.getCondition();
+    RexNode condition;
+    if (programCondition == null) {
+      condition = null;
+    } else {
+      condition = program.expandLocalRef(programCondition);
+    }
+    return estimateFilteredRows(child, condition, mq);
+  }
+
+  public static double estimateFilteredRows(RelNode child, RexNode condition,
+      RelMetadataQuery mq) {
+    return mq.getRowCount(child)
+        * mq.getSelectivity(child, condition);
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /** Visitor that walks over a scalar expression and computes the
    * cardinality of its result. */
   private static class CardOfProjExpr extends RexVisitorImpl<Double> {
+    private final RelMetadataQuery mq;
     private Project rel;
 
-    public CardOfProjExpr(Project rel) {
+    public CardOfProjExpr(RelMetadataQuery mq, Project rel) {
       super(true);
+      this.mq = mq;
       this.rel = rel;
     }
 
@@ -740,57 +737,45 @@ public class RelMdUtil {
       int index = var.getIndex();
       ImmutableBitSet col = ImmutableBitSet.of(index);
       Double distinctRowCount =
-          RelMetadataQuery.getDistinctRowCount(
-              rel.getInput(),
-              col,
-              null);
+          mq.getDistinctRowCount(rel.getInput(), col, null);
       if (distinctRowCount == null) {
         return null;
       } else {
-        return RelMdUtil.numDistinctVals(
-            distinctRowCount,
-            RelMetadataQuery.getRowCount(rel));
+        return numDistinctVals(distinctRowCount, mq.getRowCount(rel));
       }
     }
 
     public Double visitLiteral(RexLiteral literal) {
-      return RelMdUtil.numDistinctVals(
-          1.0,
-          RelMetadataQuery.getRowCount(rel));
+      return numDistinctVals(1.0, mq.getRowCount(rel));
     }
 
     public Double visitCall(RexCall call) {
       Double distinctRowCount;
-      Double rowCount = RelMetadataQuery.getRowCount(rel);
+      Double rowCount = mq.getRowCount(rel);
       if (call.isA(SqlKind.MINUS_PREFIX)) {
-        distinctRowCount =
-            cardOfProjExpr(rel, call.getOperands().get(0));
+        distinctRowCount = cardOfProjExpr(mq, rel, call.getOperands().get(0));
       } else if (call.isA(ImmutableList.of(SqlKind.PLUS, SqlKind.MINUS))) {
-        Double card0 = cardOfProjExpr(rel, call.getOperands().get(0));
+        Double card0 = cardOfProjExpr(mq, rel, call.getOperands().get(0));
         if (card0 == null) {
           return null;
         }
-        Double card1 = cardOfProjExpr(rel, call.getOperands().get(1));
+        Double card1 = cardOfProjExpr(mq, rel, call.getOperands().get(1));
         if (card1 == null) {
           return null;
         }
         distinctRowCount = Math.max(card0, card1);
-      } else if (call.isA(
-          ImmutableList.of(SqlKind.TIMES, SqlKind.DIVIDE))) {
+      } else if (call.isA(ImmutableList.of(SqlKind.TIMES, SqlKind.DIVIDE))) {
         distinctRowCount =
             NumberUtil.multiply(
-                cardOfProjExpr(rel, call.getOperands().get(0)),
-                cardOfProjExpr(rel, call.getOperands().get(1)));
+                cardOfProjExpr(mq, rel, call.getOperands().get(0)),
+                cardOfProjExpr(mq, rel, call.getOperands().get(1)));
 
         // TODO zfong 6/21/06 - Broadbase has code to handle date
         // functions like year, month, day; E.g., cardinality of Month()
         // is 12
       } else {
         if (call.getOperands().size() == 1) {
-          distinctRowCount =
-              cardOfProjExpr(
-                  rel,
-                  call.getOperands().get(0));
+          distinctRowCount = cardOfProjExpr(mq, rel, call.getOperands().get(0));
         } else {
           distinctRowCount = rowCount / 10;
         }
@@ -805,13 +790,11 @@ public class RelMdUtil {
    *
    * <p>If this is the case, it is safe to push down a
    * {@link org.apache.calcite.rel.core.Sort} with limit and optional offset. */
-  public static boolean checkInputForCollationAndLimit(RelNode input,
-      RelCollation collation, RexNode offset, RexNode fetch) {
+  public static boolean checkInputForCollationAndLimit(RelMetadataQuery mq,
+      RelNode input, RelCollation collation, RexNode offset, RexNode fetch) {
     // Check if the input is already sorted
-    ImmutableList<RelCollation> inputCollations =
-        RelMetadataQuery.collations(input);
     boolean alreadySorted = false;
-    for (RelCollation inputCollation : inputCollations) {
+    for (RelCollation inputCollation : mq.collations(input)) {
       if (inputCollation.satisfies(collation)) {
         alreadySorted = true;
         break;
@@ -819,7 +802,7 @@ public class RelMdUtil {
     }
     // Check if we are not reducing the number of tuples
     boolean alreadySmaller = true;
-    final Double rowCount = RelMetadataQuery.getMaxRowCount(input);
+    final Double rowCount = mq.getMaxRowCount(input);
     if (rowCount != null && fetch != null) {
       final int offsetVal = offset == null ? 0 : RexLiteral.intValue(offset);
       final int limit = RexLiteral.intValue(fetch);

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
index 0e1bf4f..a2fd272 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataProvider.java
@@ -18,8 +18,6 @@ package org.apache.calcite.rel.metadata;
 
 import org.apache.calcite.rel.RelNode;
 
-import com.google.common.base.Function;
-
 /**
  * RelMetadataProvider defines an interface for obtaining metadata about
  * relational expressions. This interface is weakly-typed and is not intended to
@@ -56,9 +54,9 @@ public interface RelMetadataProvider {
    * @return Function that will field a metadata instance; or null if this
    *     provider cannot supply metadata of this type
    */
-  Function<RelNode, Metadata> apply(
-      Class<? extends RelNode> relClass,
-      Class<? extends Metadata> metadataClass);
+  <M extends Metadata> UnboundMetadata<M>
+  apply(Class<? extends RelNode> relClass,
+      Class<? extends M> metadataClass);
 }
 
 // End RelMetadataProvider.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
index 44d0724..f4eb748 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
@@ -30,6 +30,7 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -64,14 +65,26 @@ import java.util.Set;
  * custom providers for the standard queries in order to handle additional
  * relational expressions (either logical or physical). In either case, the
  * process is the same: write a reflective provider and chain it on to an
- * instance of {@link DefaultRelMetadataProvider}, prepending it to the default
+ * instance of {@link DefaultRelMetadataProvider}, pre-pending it to the default
  * providers. Then supply that instance to the planner via the appropriate
  * plugin mechanism.
  */
 public abstract class RelMetadataQuery {
+  /** Set of active metadata queries. */
+  public final Set<List> set = new HashSet<>();
+
   //~ Methods ----------------------------------------------------------------
 
   /**
+   * Returns an instance of RelMetadataQuery. It ensures that cycles do not
+   * occur while computing metadata.
+   */
+  public static RelMetadataQuery instance() {
+    return new RelMetadataQuery() {
+    };
+  }
+
+  /**
    * Returns the
    * {@link BuiltInMetadata.RowCount#getRowCount()}
    * statistic.
@@ -80,9 +93,9 @@ public abstract class RelMetadataQuery {
    * @return estimated row count, or null if no reliable estimate can be
    * determined
    */
-  public static Double getRowCount(RelNode rel) {
+  public Double getRowCount(RelNode rel) {
     final BuiltInMetadata.RowCount metadata =
-        rel.metadata(BuiltInMetadata.RowCount.class);
+        rel.metadata(BuiltInMetadata.RowCount.class, this);
     Double result = metadata.getRowCount();
     return validateResult(result);
   }
@@ -95,9 +108,9 @@ public abstract class RelMetadataQuery {
    * @param rel the relational expression
    * @return max row count
    */
-  public static Double getMaxRowCount(RelNode rel) {
+  public Double getMaxRowCount(RelNode rel) {
     final BuiltInMetadata.MaxRowCount metadata =
-        rel.metadata(BuiltInMetadata.MaxRowCount.class);
+        rel.metadata(BuiltInMetadata.MaxRowCount.class, this);
     return metadata.getMaxRowCount();
   }
 
@@ -109,9 +122,9 @@ public abstract class RelMetadataQuery {
    * @param rel the relational expression
    * @return estimated cost, or null if no reliable estimate can be determined
    */
-  public static RelOptCost getCumulativeCost(RelNode rel) {
+  public RelOptCost getCumulativeCost(RelNode rel) {
     final BuiltInMetadata.CumulativeCost metadata =
-        rel.metadata(BuiltInMetadata.CumulativeCost.class);
+        rel.metadata(BuiltInMetadata.CumulativeCost.class, this);
     return metadata.getCumulativeCost();
   }
 
@@ -123,9 +136,9 @@ public abstract class RelMetadataQuery {
    * @param rel the relational expression
    * @return estimated cost, or null if no reliable estimate can be determined
    */
-  public static RelOptCost getNonCumulativeCost(RelNode rel) {
+  public RelOptCost getNonCumulativeCost(RelNode rel) {
     final BuiltInMetadata.NonCumulativeCost metadata =
-        rel.metadata(BuiltInMetadata.NonCumulativeCost.class);
+        rel.metadata(BuiltInMetadata.NonCumulativeCost.class, this);
     return metadata.getNonCumulativeCost();
   }
 
@@ -138,9 +151,9 @@ public abstract class RelMetadataQuery {
    * @return estimated percentage (between 0.0 and 1.0), or null if no
    * reliable estimate can be determined
    */
-  public static Double getPercentageOriginalRows(RelNode rel) {
+  public Double getPercentageOriginalRows(RelNode rel) {
     final BuiltInMetadata.PercentageOriginalRows metadata =
-        rel.metadata(BuiltInMetadata.PercentageOriginalRows.class);
+        rel.metadata(BuiltInMetadata.PercentageOriginalRows.class, this);
     Double result = metadata.getPercentageOriginalRows();
     assert isPercentage(result, true);
     return result;
@@ -157,9 +170,9 @@ public abstract class RelMetadataQuery {
    * determined (whereas empty set indicates definitely no origin columns at
    * all)
    */
-  public static Set<RelColumnOrigin> getColumnOrigins(RelNode rel, int column) {
+  public Set<RelColumnOrigin> getColumnOrigins(RelNode rel, int column) {
     final BuiltInMetadata.ColumnOrigin metadata =
-        rel.metadata(BuiltInMetadata.ColumnOrigin.class);
+        rel.metadata(BuiltInMetadata.ColumnOrigin.class, this);
     return metadata.getColumnOrigins(column);
   }
 
@@ -176,7 +189,7 @@ public abstract class RelMetadataQuery {
    * @return the origin of a column provided it's a simple column; otherwise,
    * returns null
    */
-  public static RelColumnOrigin getColumnOrigin(RelNode rel, int column) {
+  public RelColumnOrigin getColumnOrigin(RelNode rel, int column) {
     final Set<RelColumnOrigin> origins = getColumnOrigins(rel, column);
     if (origins == null || origins.size() != 1) {
       return null;
@@ -193,12 +206,11 @@ public abstract class RelMetadataQuery {
    *
    * @return the table, if the RelNode is a simple table; otherwise null
    */
-  public static RelOptTable getTableOrigin(RelNode rel) {
+  public RelOptTable getTableOrigin(RelNode rel) {
     // Determine the simple origin of the first column in the
     // RelNode.  If it's simple, then that means that the underlying
     // table is also simple, even if the column itself is derived.
-    final Set<RelColumnOrigin> colOrigins =
-        getColumnOrigins(rel, 0);
+    final Set<RelColumnOrigin> colOrigins = getColumnOrigins(rel, 0);
     if (colOrigins == null || colOrigins.size() == 0) {
       return null;
     }
@@ -212,13 +224,13 @@ public abstract class RelMetadataQuery {
    *
    * @param rel       the relational expression
    * @param predicate predicate whose selectivity is to be estimated against
-   *                  rel's output
+   *                  {@code rel}'s output
    * @return estimated selectivity (between 0.0 and 1.0), or null if no
    * reliable estimate can be determined
    */
-  public static Double getSelectivity(RelNode rel, RexNode predicate) {
+  public Double getSelectivity(RelNode rel, RexNode predicate) {
     final BuiltInMetadata.Selectivity metadata =
-        rel.metadata(BuiltInMetadata.Selectivity.class);
+        rel.metadata(BuiltInMetadata.Selectivity.class, this);
     Double result = metadata.getSelectivity(predicate);
     assert isPercentage(result, true);
     return result;
@@ -233,9 +245,9 @@ public abstract class RelMetadataQuery {
    * @return set of keys, or null if this information cannot be determined
    * (whereas empty set indicates definitely no keys at all)
    */
-  public static Set<ImmutableBitSet> getUniqueKeys(RelNode rel) {
+  public Set<ImmutableBitSet> getUniqueKeys(RelNode rel) {
     final BuiltInMetadata.UniqueKeys metadata =
-        rel.metadata(BuiltInMetadata.UniqueKeys.class);
+        rel.metadata(BuiltInMetadata.UniqueKeys.class, this);
     return metadata.getUniqueKeys(false);
   }
 
@@ -247,13 +259,14 @@ public abstract class RelMetadataQuery {
    * @param rel         the relational expression
    * @param ignoreNulls if true, ignore null values when determining
    *                    whether the keys are unique
+   *
    * @return set of keys, or null if this information cannot be determined
    * (whereas empty set indicates definitely no keys at all)
    */
-  public static Set<ImmutableBitSet> getUniqueKeys(RelNode rel,
+  public Set<ImmutableBitSet> getUniqueKeys(RelNode rel,
       boolean ignoreNulls) {
     final BuiltInMetadata.UniqueKeys metadata =
-        rel.metadata(BuiltInMetadata.UniqueKeys.class);
+        rel.metadata(BuiltInMetadata.UniqueKeys.class, this);
     return metadata.getUniqueKeys(ignoreNulls);
   }
 
@@ -264,12 +277,13 @@ public abstract class RelMetadataQuery {
    * statistic over all columns.
    *
    * @param rel     the relational expression
+   *
    * @return true or false depending on whether the rows are unique, or
    * null if not enough information is available to make that determination
    */
-  public static Boolean areRowsUnique(RelNode rel) {
+  public Boolean areRowsUnique(RelNode rel) {
     final BuiltInMetadata.ColumnUniqueness metadata =
-        rel.metadata(BuiltInMetadata.ColumnUniqueness.class);
+        rel.metadata(BuiltInMetadata.ColumnUniqueness.class, this);
     final ImmutableBitSet columns =
         ImmutableBitSet.range(rel.getRowType().getFieldCount());
     return metadata.areColumnsUnique(columns, false);
@@ -277,24 +291,25 @@ public abstract class RelMetadataQuery {
 
   /**
    * Returns the
-   * {@link BuiltInMetadata.ColumnUniqueness#areColumnsUnique(org.apache.calcite.util.ImmutableBitSet, boolean)}
+   * {@link BuiltInMetadata.ColumnUniqueness#areColumnsUnique(ImmutableBitSet, boolean)}
    * statistic.
    *
    * @param rel     the relational expression
    * @param columns column mask representing the subset of columns for which
    *                uniqueness will be determined
+   *
    * @return true or false depending on whether the columns are unique, or
    * null if not enough information is available to make that determination
    */
-  public static Boolean areColumnsUnique(RelNode rel, ImmutableBitSet columns) {
+  public Boolean areColumnsUnique(RelNode rel, ImmutableBitSet columns) {
     final BuiltInMetadata.ColumnUniqueness metadata =
-        rel.metadata(BuiltInMetadata.ColumnUniqueness.class);
+        rel.metadata(BuiltInMetadata.ColumnUniqueness.class, this);
     return metadata.areColumnsUnique(columns, false);
   }
 
   /**
    * Returns the
-   * {@link BuiltInMetadata.ColumnUniqueness#areColumnsUnique(org.apache.calcite.util.ImmutableBitSet, boolean)}
+   * {@link BuiltInMetadata.ColumnUniqueness#areColumnsUnique(ImmutableBitSet, boolean)}
    * statistic.
    *
    * @param rel         the relational expression
@@ -305,46 +320,46 @@ public abstract class RelMetadataQuery {
    * @return true or false depending on whether the columns are unique, or
    * null if not enough information is available to make that determination
    */
-  public static Boolean areColumnsUnique(RelNode rel, ImmutableBitSet columns,
+  public Boolean areColumnsUnique(RelNode rel, ImmutableBitSet columns,
       boolean ignoreNulls) {
     final BuiltInMetadata.ColumnUniqueness metadata =
-        rel.metadata(BuiltInMetadata.ColumnUniqueness.class);
+        rel.metadata(BuiltInMetadata.ColumnUniqueness.class, this);
     return metadata.areColumnsUnique(columns, ignoreNulls);
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Collation#collations()}
+   * {@link BuiltInMetadata.Collation#collations()}
    * statistic.
    *
    * @param rel         the relational expression
    * @return List of sorted column combinations, or
    * null if not enough information is available to make that determination
    */
-  public static ImmutableList<RelCollation> collations(RelNode rel) {
+  public ImmutableList<RelCollation> collations(RelNode rel) {
     final BuiltInMetadata.Collation metadata =
-        rel.metadata(BuiltInMetadata.Collation.class);
+        rel.metadata(BuiltInMetadata.Collation.class, this);
     return metadata.collations();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Distribution#distribution()}
+   * {@link BuiltInMetadata.Distribution#distribution()}
    * statistic.
    *
    * @param rel         the relational expression
    * @return List of sorted column combinations, or
    * null if not enough information is available to make that determination
    */
-  public static RelDistribution distribution(RelNode rel) {
+  public RelDistribution distribution(RelNode rel) {
     final BuiltInMetadata.Distribution metadata =
-        rel.metadata(BuiltInMetadata.Distribution.class);
+        rel.metadata(BuiltInMetadata.Distribution.class, this);
     return metadata.distribution();
   }
 
   /**
    * Returns the
-   * {@link BuiltInMetadata.PopulationSize#getPopulationSize(org.apache.calcite.util.ImmutableBitSet)}
+   * {@link BuiltInMetadata.PopulationSize#getPopulationSize(ImmutableBitSet)}
    * statistic.
    *
    * @param rel      the relational expression
@@ -354,31 +369,31 @@ public abstract class RelMetadataQuery {
    * estimate can be determined
    *
    */
-  public static Double getPopulationSize(RelNode rel,
+  public Double getPopulationSize(RelNode rel,
       ImmutableBitSet groupKey) {
     final BuiltInMetadata.PopulationSize metadata =
-        rel.metadata(BuiltInMetadata.PopulationSize.class);
+        rel.metadata(BuiltInMetadata.PopulationSize.class, this);
     Double result = metadata.getPopulationSize(groupKey);
     return validateResult(result);
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Size#averageRowSize()}
+   * {@link BuiltInMetadata.Size#averageRowSize()}
    * statistic.
    *
    * @param rel      the relational expression
    * @return average size of a row, in bytes, or null if not known
      */
-  public static Double getAverageRowSize(RelNode rel) {
+  public Double getAverageRowSize(RelNode rel) {
     final BuiltInMetadata.Size metadata =
-        rel.metadata(BuiltInMetadata.Size.class);
+        rel.metadata(BuiltInMetadata.Size.class, this);
     return metadata.averageRowSize();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Size#averageColumnSizes()}
+   * {@link BuiltInMetadata.Size#averageColumnSizes()}
    * statistic.
    *
    * @param rel      the relational expression
@@ -386,17 +401,17 @@ public abstract class RelMetadataQuery {
    * value, in bytes. Each value or the entire list may be null if the
    * metadata is not available
    */
-  public static List<Double> getAverageColumnSizes(RelNode rel) {
+  public List<Double> getAverageColumnSizes(RelNode rel) {
     final BuiltInMetadata.Size metadata =
-        rel.metadata(BuiltInMetadata.Size.class);
+        rel.metadata(BuiltInMetadata.Size.class, this);
     return metadata.averageColumnSizes();
   }
 
   /** As {@link #getAverageColumnSizes(org.apache.calcite.rel.RelNode)} but
    * never returns a null list, only ever a list of nulls. */
-  public static List<Double> getAverageColumnSizesNotNull(RelNode rel) {
+  public List<Double> getAverageColumnSizesNotNull(RelNode rel) {
     final BuiltInMetadata.Size metadata =
-        rel.metadata(BuiltInMetadata.Size.class);
+        rel.metadata(BuiltInMetadata.Size.class, this);
     final List<Double> averageColumnSizes = metadata.averageColumnSizes();
     return averageColumnSizes == null
         ? Collections.<Double>nCopies(rel.getRowType().getFieldCount(), null)
@@ -405,7 +420,7 @@ public abstract class RelMetadataQuery {
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Parallelism#isPhaseTransition()}
+   * {@link BuiltInMetadata.Parallelism#isPhaseTransition()}
    * statistic.
    *
    * @param rel      the relational expression
@@ -413,29 +428,29 @@ public abstract class RelMetadataQuery {
    * expression belongs to a different process than its inputs, or null if not
    * known
    */
-  public static Boolean isPhaseTransition(RelNode rel) {
+  public Boolean isPhaseTransition(RelNode rel) {
     final BuiltInMetadata.Parallelism metadata =
-        rel.metadata(BuiltInMetadata.Parallelism.class);
+        rel.metadata(BuiltInMetadata.Parallelism.class, this);
     return metadata.isPhaseTransition();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Parallelism#splitCount()}
+   * {@link BuiltInMetadata.Parallelism#splitCount()}
    * statistic.
    *
    * @param rel      the relational expression
    * @return the number of distinct splits of the data, or null if not known
    */
-  public static Integer splitCount(RelNode rel) {
+  public Integer splitCount(RelNode rel) {
     final BuiltInMetadata.Parallelism metadata =
-        rel.metadata(BuiltInMetadata.Parallelism.class);
+        rel.metadata(BuiltInMetadata.Parallelism.class, this);
     return metadata.splitCount();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Memory#memory()}
+   * {@link BuiltInMetadata.Memory#memory()}
    * statistic.
    *
    * @param rel      the relational expression
@@ -443,15 +458,15 @@ public abstract class RelMetadataQuery {
    * operator implementing this relational expression, across all splits,
    * or null if not known
    */
-  public static Double memory(RelNode rel) {
+  public Double memory(RelNode rel) {
     final BuiltInMetadata.Memory metadata =
-        rel.metadata(BuiltInMetadata.Memory.class);
+        rel.metadata(BuiltInMetadata.Memory.class, this);
     return metadata.memory();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Memory#cumulativeMemoryWithinPhase()}
+   * {@link BuiltInMetadata.Memory#cumulativeMemoryWithinPhase()}
    * statistic.
    *
    * @param rel      the relational expression
@@ -459,15 +474,15 @@ public abstract class RelMetadataQuery {
    * physical operator implementing this relational expression, and all other
    * operators within the same phase, across all splits, or null if not known
    */
-  public static Double cumulativeMemoryWithinPhase(RelNode rel) {
+  public Double cumulativeMemoryWithinPhase(RelNode rel) {
     final BuiltInMetadata.Memory metadata =
-        rel.metadata(BuiltInMetadata.Memory.class);
+        rel.metadata(BuiltInMetadata.Memory.class, this);
     return metadata.cumulativeMemoryWithinPhase();
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Memory#cumulativeMemoryWithinPhaseSplit()}
+   * {@link BuiltInMetadata.Memory#cumulativeMemoryWithinPhaseSplit()}
    * statistic.
    *
    * @param rel      the relational expression
@@ -475,15 +490,15 @@ public abstract class RelMetadataQuery {
    * the physical operator implementing this relational expression, and all
    * operators within the same phase, within each split, or null if not known
    */
-  public static Double cumulativeMemoryWithinPhaseSplit(RelNode rel) {
+  public Double cumulativeMemoryWithinPhaseSplit(RelNode rel) {
     final BuiltInMetadata.Memory metadata =
-        rel.metadata(BuiltInMetadata.Memory.class);
+        rel.metadata(BuiltInMetadata.Memory.class, this);
     return metadata.cumulativeMemoryWithinPhaseSplit();
   }
 
   /**
    * Returns the
-   * {@link BuiltInMetadata.DistinctRowCount#getDistinctRowCount(org.apache.calcite.util.ImmutableBitSet, org.apache.calcite.rex.RexNode)}
+   * {@link BuiltInMetadata.DistinctRowCount#getDistinctRowCount(ImmutableBitSet, RexNode)}
    * statistic.
    *
    * @param rel       the relational expression
@@ -492,27 +507,27 @@ public abstract class RelMetadataQuery {
    * @return distinct row count for groupKey, filtered by predicate, or null
    * if no reliable estimate can be determined
    */
-  public static Double getDistinctRowCount(
+  public Double getDistinctRowCount(
       RelNode rel,
       ImmutableBitSet groupKey,
       RexNode predicate) {
     final BuiltInMetadata.DistinctRowCount metadata =
-        rel.metadata(BuiltInMetadata.DistinctRowCount.class);
+        rel.metadata(BuiltInMetadata.DistinctRowCount.class, this);
     Double result = metadata.getDistinctRowCount(groupKey, predicate);
     return validateResult(result);
   }
 
   /**
    * Returns the
-   * {@link org.apache.calcite.rel.metadata.BuiltInMetadata.Predicates#getPredicates()}
+   * {@link BuiltInMetadata.Predicates#getPredicates()}
    * statistic.
    *
    * @param rel the relational expression
    * @return Predicates that can be pulled above this RelNode
    */
-  public static RelOptPredicateList getPulledUpPredicates(RelNode rel) {
+  public RelOptPredicateList getPulledUpPredicates(RelNode rel) {
     final BuiltInMetadata.Predicates metadata =
-        rel.metadata(BuiltInMetadata.Predicates.class);
+        rel.metadata(BuiltInMetadata.Predicates.class, this);
     return metadata.getPredicates();
   }
 
@@ -526,10 +541,10 @@ public abstract class RelMetadataQuery {
    * @return true for visible, false for invisible; if no metadata is available,
    * defaults to true
    */
-  public static boolean isVisibleInExplain(RelNode rel,
+  public boolean isVisibleInExplain(RelNode rel,
       SqlExplainLevel explainLevel) {
     final BuiltInMetadata.ExplainVisibility metadata =
-        rel.metadata(BuiltInMetadata.ExplainVisibility.class);
+        rel.metadata(BuiltInMetadata.ExplainVisibility.class, this);
     Boolean b = metadata.isVisibleInExplain(explainLevel);
     return b == null || b;
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/metadata/UnboundMetadata.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/UnboundMetadata.java b/core/src/main/java/org/apache/calcite/rel/metadata/UnboundMetadata.java
new file mode 100644
index 0000000..ef8dc4a
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/UnboundMetadata.java
@@ -0,0 +1,31 @@
+/*
+ * 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.rel.metadata;
+
+import org.apache.calcite.rel.RelNode;
+
+/**
+ * Metadata that needs to be bound to a {@link RelNode} and
+ * {@link RelMetadataQuery} before it can be used.
+ *
+ * @param <M> Metadata type
+ */
+public interface UnboundMetadata<M extends Metadata> {
+  M bind(RelNode rel, RelMetadataQuery mq);
+}
+
+// End UnboundMetadata.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
index 52b5497..b2ebf84 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
@@ -72,8 +72,8 @@ public class AggregateFilterTransposeRule extends RelOptRule {
     final ImmutableBitSet newGroupSet =
         aggregate.getGroupSet().union(filterColumns);
     final RelNode input = filter.getInput();
-    final Boolean unique =
-        RelMetadataQuery.areColumnsUnique(input, newGroupSet);
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    final Boolean unique = mq.areColumnsUnique(input, newGroupSet);
     if (unique != null && unique) {
       // The input is already unique on the grouping columns, so there's little
       // advantage of aggregating again. More important, without this check,

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
index 016e45a..6978e04 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
@@ -38,7 +38,9 @@ import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlSplittableAggFunction;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
+import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.calcite.util.Util;
 import org.apache.calcite.util.mapping.Mapping;
 import org.apache.calcite.util.mapping.Mappings;
 
@@ -153,8 +155,9 @@ public class AggregateJoinTransposeRule extends RelOptRule {
 
     // Do the columns used by the join appear in the output of the aggregate?
     final ImmutableBitSet aggregateColumns = aggregate.getGroupSet();
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     final ImmutableBitSet keyColumns = keyColumns(aggregateColumns,
-        RelMetadataQuery.getPulledUpPredicates(join).pulledUpPredicates);
+        mq.getPulledUpPredicates(join).pulledUpPredicates);
     final ImmutableBitSet joinColumns =
         RelOptUtil.InputFinder.bits(join.getCondition());
     final boolean allColumnsInAggregate =
@@ -202,17 +205,18 @@ public class AggregateJoinTransposeRule extends RelOptRule {
         // any functions experiencing a cartesian product effect.
         //
         // But finding out whether the input is already unique requires a call
-        // to areColumnsUnique that currently (until [CALCITE-794] "Detect
-        // cycles when computing statistics" is fixed) places a heavy load on
+        // to areColumnsUnique that currently (until [CALCITE-1048] "Make
+        // metadata more robust" is fixed) places a heavy load on
         // the metadata system.
         //
         // So we choose to imagine the the input is already unique, which is
         // untrue but harmless.
         //
+        Util.discard(Bug.CALCITE_1048_FIXED);
         unique = true;
       } else {
         final Boolean unique0 =
-            RelMetadataQuery.areColumnsUnique(joinInput, belowAggregateKey);
+            mq.areColumnsUnique(joinInput, belowAggregateKey);
         unique = unique0 != null && unique0;
       }
       if (unique) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
index a0ff130..bb7797e 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
@@ -109,8 +109,9 @@ public class AggregateProjectPullUpConstantsRule extends RelOptRule {
     }
 
     final RexBuilder rexBuilder = aggregate.getCluster().getRexBuilder();
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     final RelOptPredicateList predicates =
-        RelMetadataQuery.getPulledUpPredicates(aggregate.getInput());
+        mq.getPulledUpPredicates(aggregate.getInput());
     if (predicates == null) {
       return;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
index aa74448..b98ba64 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
@@ -57,10 +57,11 @@ public class AggregateRemoveRule extends RelOptRule {
   public void onMatch(RelOptRuleCall call) {
     final LogicalAggregate aggregate = call.rel(0);
     final RelNode input = call.rel(1);
-    if (!aggregate.getAggCallList().isEmpty()
-        || aggregate.indicator
-        || !SqlFunctions.isTrue(
-            RelMetadataQuery.areColumnsUnique(input, aggregate.getGroupSet()))) {
+    if (!aggregate.getAggCallList().isEmpty() || aggregate.indicator) {
+      return;
+    }
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    if (!SqlFunctions.isTrue(mq.areColumnsUnique(input, aggregate.getGroupSet()))) {
       return;
     }
     // Distinct is "GROUP BY c1, c2" (where c1, c2 are a set of columns on

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
index 7464a0f..3945924 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
@@ -33,6 +33,7 @@ import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Aggregate;
 import org.apache.calcite.rel.core.AggregateCall;
 import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.schema.impl.StarTable;
@@ -115,7 +116,8 @@ public class AggregateStarTableRule extends RelOptRule {
     final RelBuilder relBuilder = call.builder();
     final CalciteSchema.TableEntry tableEntry = pair.left;
     final TileKey tileKey = pair.right;
-    final double rowCount = aggregate.getRows();
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    final double rowCount = aggregate.estimateRowCount(mq);
     final Table aggregateTable = tableEntry.getTable();
     final RelDataType aggregateTableRowType =
         aggregateTable.getRowType(cluster.getTypeFactory());

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
index 2a2ef98..12300d9 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
@@ -27,6 +27,7 @@ import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rel.logical.LogicalAggregate;
 import org.apache.calcite.rel.logical.LogicalUnion;
 import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.fun.SqlCountAggFunction;
@@ -115,10 +116,10 @@ public class AggregateUnionTransposeRule extends RelOptRule {
     // create corresponding aggregates on top of each union child
     final RelBuilder relBuilder = call.builder();
     int transformCount = 0;
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     for (RelNode input : union.getInputs()) {
       boolean alreadyUnique =
-          RelMdUtil.areColumnsDefinitelyUnique(
-              input,
+          RelMdUtil.areColumnsDefinitelyUnique(mq, input,
               aggRel.getGroupSet());
 
       relBuilder.push(input);

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
index 1d375c6..0b020c7 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
@@ -59,7 +59,8 @@ public class JoinPushTransitivePredicatesRule extends RelOptRule {
 
   @Override public void onMatch(RelOptRuleCall call) {
     Join join = call.rel(0);
-    RelOptPredicateList preds = RelMetadataQuery.getPulledUpPredicates(join);
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    RelOptPredicateList preds = mq.getPulledUpPredicates(join);
 
     if (preds.leftInferredPredicates.isEmpty()
         && preds.rightInferredPredicates.isEmpty()) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
index a41e1aa..ee4eeaa 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
@@ -192,7 +192,7 @@ public class LoptMultiJoin {
     joinFilters =
         Lists.newArrayList(RelOptUtil.conjunctions(multiJoin.getJoinFilter()));
 
-    allJoinFilters = new ArrayList<RexNode>(joinFilters);
+    allJoinFilters = new ArrayList<>(joinFilters);
     List<RexNode> outerJoinFilters = multiJoin.getOuterJoinConditions();
     for (int i = 0; i < nJoinFactors; i++) {
       allJoinFilters.addAll(RelOptUtil.conjunctions(outerJoinFilters.get(i)));
@@ -235,8 +235,8 @@ public class LoptMultiJoin {
     joinRemovalFactors = new Integer[nJoinFactors];
     joinRemovalSemiJoins = new SemiJoin[nJoinFactors];
 
-    removableOuterJoinFactors = new HashSet<Integer>();
-    removableSelfJoinPairs = new HashMap<Integer, RemovableSelfJoin>();
+    removableOuterJoinFactors = new HashSet<>();
+    removableSelfJoinPairs = new HashMap<>();
   }
 
   //~ Methods ----------------------------------------------------------------
@@ -695,15 +695,15 @@ public class LoptMultiJoin {
     // Compute a column mapping such that if a column from the right
     // factor is also referenced in the left factor, we will map the
     // right reference to the left to avoid redundant references.
-    Map<Integer, Integer> columnMapping = new HashMap<Integer, Integer>();
+    final Map<Integer, Integer> columnMapping = new HashMap<>();
 
     // First, locate the originating column for all simple column
     // references in the left factor.
-    RelNode left = getJoinFactor(leftFactor);
-    Map<Integer, Integer> leftFactorColMapping =
-        new HashMap<Integer, Integer>();
+    final RelNode left = getJoinFactor(leftFactor);
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    final Map<Integer, Integer> leftFactorColMapping = new HashMap<>();
     for (int i = 0; i < left.getRowType().getFieldCount(); i++) {
-      RelColumnOrigin colOrigin = RelMetadataQuery.getColumnOrigin(left, i);
+      final RelColumnOrigin colOrigin = mq.getColumnOrigin(left, i);
       if (colOrigin != null) {
         leftFactorColMapping.put(
             colOrigin.getOriginColumnOrdinal(),
@@ -717,8 +717,7 @@ public class LoptMultiJoin {
     // factor.
     RelNode right = getJoinFactor(rightFactor);
     for (int i = 0; i < right.getRowType().getFieldCount(); i++) {
-      final RelColumnOrigin colOrigin =
-          RelMetadataQuery.getColumnOrigin(right, i);
+      final RelColumnOrigin colOrigin = mq.getColumnOrigin(right, i);
       if (colOrigin == null) {
         continue;
       }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
index 66ae671..e522ade 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
@@ -209,9 +209,9 @@ public class LoptOptimizeJoinRule extends RelOptRule {
         // part of an equality join condition, nulls are filtered out
         // by the join.  So, it's ok if there are nulls in the join
         // keys.
-        if (RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(
-            multiJoin.getJoinFactor(factIdx),
-            joinKeys)) {
+        final RelMetadataQuery mq = RelMetadataQuery.instance();
+        if (RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(mq,
+            multiJoin.getJoinFactor(factIdx), joinKeys)) {
           multiJoin.addRemovableOuterJoinFactor(factIdx);
 
           // Since we are no longer joining this factor,
@@ -319,7 +319,7 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     // the appropriate join condition between the two factors that will
     // allow the join to be removed.
     for (Integer factor1 : selfJoinPairs.keySet()) {
-      int factor2 = selfJoinPairs.get(factor1);
+      final int factor2 = selfJoinPairs.get(factor1);
       final List<RexNode> selfJoinFilters = new ArrayList<>();
       for (RexNode filter : multiJoin.getJoinFilters()) {
         ImmutableBitSet joinFactors =
@@ -361,13 +361,14 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     if (multiJoin.getMultiJoinRel().isFullOuterJoin()) {
       return returnList;
     }
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     for (int factIdx = 0; factIdx < multiJoin.getNumJoinFactors(); factIdx++) {
       if (multiJoin.isNullGenerating(factIdx)
           || (multiJoin.getJoinRemovalFactor(factIdx) != null)) {
         continue;
       }
       final RelNode rel = multiJoin.getJoinFactor(factIdx);
-      final RelOptTable table = RelMetadataQuery.getTableOrigin(rel);
+      final RelOptTable table = mq.getTableOrigin(rel);
       if (table != null) {
         returnList.put(factIdx, table);
       }
@@ -421,7 +422,8 @@ public class LoptOptimizeJoinRule extends RelOptRule {
                 rightRel.getRowType().getFieldList(),
                 adjustments));
 
-    return areSelfJoinKeysUnique(leftRel, rightRel, joinFilters);
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    return areSelfJoinKeysUnique(mq, leftRel, rightRel, joinFilters);
   }
 
   /**
@@ -439,7 +441,7 @@ public class LoptOptimizeJoinRule extends RelOptRule {
       RelOptRuleCall call) {
     final List<RelNode> plans = new ArrayList<>();
 
-    List<String> fieldNames =
+    final List<String> fieldNames =
         multiJoin.getMultiJoinRel().getRowType().getFieldNames();
 
     // generate the N join orderings
@@ -603,10 +605,9 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     if (joinKeys.isEmpty()) {
       return null;
     } else {
-      return RelMetadataQuery.getDistinctRowCount(
-          semiJoinOpt.getChosenSemiJoin(factor),
-          joinKeys.build(),
-          null);
+      final RelMetadataQuery mq = semiJoinOpt.mq;
+      return mq.getDistinctRowCount(semiJoinOpt.getChosenSemiJoin(factor),
+          joinKeys.build(), null);
     }
   }
 
@@ -671,9 +672,9 @@ public class LoptOptimizeJoinRule extends RelOptRule {
       LoptSemiJoinOptimizer semiJoinOpt,
       int firstFactor) {
     LoptJoinTree joinTree = null;
-    int nJoinFactors = multiJoin.getNumJoinFactors();
-    BitSet factorsToAdd = BitSets.range(0, nJoinFactors);
-    BitSet factorsAdded = new BitSet(nJoinFactors);
+    final int nJoinFactors = multiJoin.getNumJoinFactors();
+    final BitSet factorsToAdd = BitSets.range(0, nJoinFactors);
+    final BitSet factorsAdded = new BitSet(nJoinFactors);
     final List<RexNode> filtersToAdd =
         new ArrayList<>(multiJoin.getJoinFilters());
 
@@ -867,6 +868,8 @@ public class LoptOptimizeJoinRule extends RelOptRule {
       BitSet factorsNeeded,
       List<RexNode> filtersToAdd,
       boolean selfJoin) {
+    final RelMetadataQuery mq = semiJoinOpt.mq;
+
     // if the factor corresponds to the null generating factor in an outer
     // join that can be removed, then create a replacement join
     if (multiJoin.isRemovableOuterJoinFactor(factorToAdd)) {
@@ -935,11 +938,10 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     RelOptCost costPushDown = null;
     RelOptCost costTop = null;
     if (pushDownTree != null) {
-      costPushDown =
-          RelMetadataQuery.getCumulativeCost(pushDownTree.getJoinTree());
+      costPushDown = mq.getCumulativeCost(pushDownTree.getJoinTree());
     }
     if (topTree != null) {
-      costTop = RelMetadataQuery.getCumulativeCost(topTree.getJoinTree());
+      costTop = mq.getCumulativeCost(topTree.getJoinTree());
     }
 
     if (pushDownTree == null) {
@@ -1337,7 +1339,7 @@ public class LoptOptimizeJoinRule extends RelOptRule {
       int factorAdded,
       List<Integer> origJoinOrder,
       List<RelDataTypeField> origFields) {
-    List<Integer> newJoinOrder = new ArrayList<>();
+    final List<Integer> newJoinOrder = new ArrayList<>();
     left.getTreeOrder(newJoinOrder);
     right.getTreeOrder(newJoinOrder);
 
@@ -1858,8 +1860,9 @@ public class LoptOptimizeJoinRule extends RelOptRule {
           ((LoptJoinTree.Leaf) left.getFactorTree()).getId());
     }
 
-    Double leftRowCount = RelMetadataQuery.getRowCount(left.getJoinTree());
-    Double rightRowCount = RelMetadataQuery.getRowCount(right.getJoinTree());
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    final Double leftRowCount = mq.getRowCount(left.getJoinTree());
+    final Double rightRowCount = mq.getRowCount(right.getJoinTree());
 
     // The left side is smaller than the right if it has fewer rows,
     // or if it has the same number of rows as the right (excluding
@@ -1990,11 +1993,12 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     }
 
     // Make sure the join is between the same simple factor
-    final RelOptTable leftTable = RelMetadataQuery.getTableOrigin(left);
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
+    final RelOptTable leftTable = mq.getTableOrigin(left);
     if (leftTable == null) {
       return false;
     }
-    final RelOptTable rightTable = RelMetadataQuery.getTableOrigin(right);
+    final RelOptTable rightTable = mq.getTableOrigin(right);
     if (rightTable == null) {
       return false;
     }
@@ -2003,35 +2007,34 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     }
 
     // Determine if the join keys are identical and unique
-    return areSelfJoinKeysUnique(left, right, joinRel.getCondition());
+    return areSelfJoinKeysUnique(mq, left, right, joinRel.getCondition());
   }
 
   /**
    * Determines if the equality portion of a self-join condition is between
    * identical keys that are unique.
    *
+   * @param mq Metadata query
    * @param leftRel left side of the join
    * @param rightRel right side of the join
    * @param joinFilters the join condition
    *
    * @return true if the equality join keys are the same and unique
    */
-  private static boolean areSelfJoinKeysUnique(
-      RelNode leftRel,
-      RelNode rightRel,
-      RexNode joinFilters) {
+  private static boolean areSelfJoinKeysUnique(RelMetadataQuery mq,
+      RelNode leftRel, RelNode rightRel, RexNode joinFilters) {
     final JoinInfo joinInfo = JoinInfo.of(leftRel, rightRel, joinFilters);
 
     // Make sure each key on the left maps to the same simple column as the
     // corresponding key on the right
     for (IntPair pair : joinInfo.pairs()) {
       final RelColumnOrigin leftOrigin =
-          RelMetadataQuery.getColumnOrigin(leftRel, pair.source);
+          mq.getColumnOrigin(leftRel, pair.source);
       if (leftOrigin == null) {
         return false;
       }
       final RelColumnOrigin rightOrigin =
-          RelMetadataQuery.getColumnOrigin(rightRel, pair.target);
+          mq.getColumnOrigin(rightRel, pair.target);
       if (rightOrigin == null) {
         return false;
       }
@@ -2045,7 +2048,7 @@ public class LoptOptimizeJoinRule extends RelOptRule {
     // are unique.  When removing self-joins, if needed, we'll later add an
     // IS NOT NULL filter on the join keys that are nullable.  Therefore,
     // it's ok if there are nulls in the unique key.
-    return RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(leftRel,
+    return RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(mq, leftRel,
         joinInfo.leftSet());
   }
 }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
index 080cb9c..308091e 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
@@ -58,10 +58,11 @@ public class LoptSemiJoinOptimizer {
 
   //~ Instance fields --------------------------------------------------------
 
-  /**
-   * RexBuilder for constructing new RexNodes
-   */
-  private RexBuilder rexBuilder;
+  private final RexBuilder rexBuilder;
+
+  /** Not thread-safe. But should be OK, because an optimizer is only used
+   * from within one thread.*/
+  final RelMetadataQuery mq = RelMetadataQuery.instance();
 
   /**
    * Semijoins corresponding to each join factor, if they are going to be
@@ -406,7 +407,7 @@ public class LoptSemiJoinOptimizer {
     while (keyIter.hasNext()) {
       boolean removeKey = false;
       final RelColumnOrigin colOrigin =
-          RelMetadataQuery.getColumnOrigin(factRel, keyIter.next());
+          mq.getColumnOrigin(factRel, keyIter.next());
 
       // can't use the rid column as a semijoin key
       if ((colOrigin == null)
@@ -635,13 +636,13 @@ public class LoptSemiJoinOptimizer {
     // a middle ground based on testing that was done with a large
     // data set.
     final ImmutableBitSet dimCols = ImmutableBitSet.of(semiJoin.getRightKeys());
-    double selectivity =
-        RelMdUtil.computeSemiJoinSelectivity(factRel, dimRel, semiJoin);
+    final double selectivity =
+        RelMdUtil.computeSemiJoinSelectivity(mq, factRel, dimRel, semiJoin);
     if (selectivity > .5) {
       return 0;
     }
 
-    RelOptCost factCost = RelMetadataQuery.getCumulativeCost(factRel);
+    final RelOptCost factCost = mq.getCumulativeCost(factRel);
 
     // if not enough information, return a low score
     if (factCost == null) {
@@ -654,9 +655,8 @@ public class LoptSemiJoinOptimizer {
     // Additional savings if the dimension columns are unique.  We can
     // ignore nulls since they will be filtered out by the semijoin.
     boolean uniq =
-        RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(
-            dimRel,
-            dimCols);
+        RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(mq,
+            dimRel, dimCols);
     if (uniq) {
       savings *= 2.0;
     }
@@ -664,9 +664,9 @@ public class LoptSemiJoinOptimizer {
     // compute the cost of doing an extra scan on the dimension table,
     // including the distinct sort on top of the scan; if the dimension
     // columns are already unique, no need to add on the dup removal cost
-    Double dimSortCost = RelMetadataQuery.getRowCount(dimRel);
-    Double dupRemCost = uniq ? 0 : dimSortCost;
-    RelOptCost dimCost = RelMetadataQuery.getCumulativeCost(dimRel);
+    final Double dimSortCost = mq.getRowCount(dimRel);
+    final Double dupRemCost = uniq ? 0 : dimSortCost;
+    final RelOptCost dimCost = mq.getCumulativeCost(dimRel);
     if ((dimSortCost == null)
         || (dupRemCost == null)
         || (dimCost == null)) {
@@ -708,9 +708,8 @@ public class LoptSemiJoinOptimizer {
     // Check if the semijoin keys corresponding to the dimension table
     // are unique.  The semijoin will filter out the nulls.
     final ImmutableBitSet dimKeys = ImmutableBitSet.of(semiJoin.getRightKeys());
-    RelNode dimRel = multiJoin.getJoinFactor(dimIdx);
-    if (!RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(
-        dimRel,
+    final RelNode dimRel = multiJoin.getJoinFactor(dimIdx);
+    if (!RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(mq, dimRel,
         dimKeys)) {
       return;
     }
@@ -800,14 +799,14 @@ public class LoptSemiJoinOptimizer {
 
   //~ Inner Classes ----------------------------------------------------------
 
-  /** . */
+  /** Compares factors. */
   private class FactorCostComparator
       implements Comparator<Integer> {
     public int compare(Integer rel1Idx, Integer rel2Idx) {
       RelOptCost c1 =
-          RelMetadataQuery.getCumulativeCost(chosenSemiJoins[rel1Idx]);
+          mq.getCumulativeCost(chosenSemiJoins[rel1Idx]);
       RelOptCost c2 =
-          RelMetadataQuery.getCumulativeCost(chosenSemiJoins[rel2Idx]);
+          mq.getCumulativeCost(chosenSemiJoins[rel2Idx]);
 
       // nulls are arbitrarily sorted
       if ((c1 == null) || (c2 == null)) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java b/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
index 477b74a..b0b372d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
@@ -87,6 +87,7 @@ public class MultiJoinOptimizeBushyRule extends RelOptRule {
     final MultiJoin multiJoinRel = call.rel(0);
     final RexBuilder rexBuilder = multiJoinRel.getCluster().getRexBuilder();
     final RelBuilder relBuilder = call.builder();
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
 
     final LoptMultiJoin multiJoin = new LoptMultiJoin(multiJoinRel);
 
@@ -94,7 +95,7 @@ public class MultiJoinOptimizeBushyRule extends RelOptRule {
     int x = 0;
     for (int i = 0; i < multiJoin.getNumJoinFactors(); i++) {
       final RelNode rel = multiJoin.getJoinFactor(i);
-      double cost = RelMetadataQuery.getRowCount(rel);
+      double cost = mq.getRowCount(rel);
       vertexes.add(new LeafVertex(i, rel, cost, x));
       x += rel.getRowType().getFieldCount();
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
index 759748c..3fce8a6 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
@@ -140,8 +140,9 @@ public abstract class ReduceExpressionsRule extends RelOptRule {
           Lists.newArrayList(filter.getCondition());
       RexNode newConditionExp;
       boolean reduced;
+      final RelMetadataQuery mq = RelMetadataQuery.instance();
       final RelOptPredicateList predicates =
-          RelMetadataQuery.getPulledUpPredicates(filter.getInput());
+          mq.getPulledUpPredicates(filter.getInput());
       if (reduceExpressions(filter, expList, predicates)) {
         assert expList.size() == 1;
         newConditionExp = expList.get(0);
@@ -229,9 +230,10 @@ public abstract class ReduceExpressionsRule extends RelOptRule {
     }
 
     @Override public void onMatch(RelOptRuleCall call) {
-      Project project = call.rel(0);
+      final Project project = call.rel(0);
+      final RelMetadataQuery mq = RelMetadataQuery.instance();
       final RelOptPredicateList predicates =
-          RelMetadataQuery.getPulledUpPredicates(project.getInput());
+          mq.getPulledUpPredicates(project.getInput());
       final List<RexNode> expList =
           Lists.newArrayList(project.getProjects());
       if (reduceExpressions(project, expList, predicates)) {
@@ -261,10 +263,11 @@ public abstract class ReduceExpressionsRule extends RelOptRule {
       final Join join = call.rel(0);
       final List<RexNode> expList = Lists.newArrayList(join.getCondition());
       final int fieldCount = join.getLeft().getRowType().getFieldCount();
+      final RelMetadataQuery mq = RelMetadataQuery.instance();
       final RelOptPredicateList leftPredicates =
-          RelMetadataQuery.getPulledUpPredicates(join.getLeft());
+          mq.getPulledUpPredicates(join.getLeft());
       final RelOptPredicateList rightPredicates =
-          RelMetadataQuery.getPulledUpPredicates(join.getRight());
+          mq.getPulledUpPredicates(join.getRight());
       final RelOptPredicateList predicates =
           leftPredicates.union(rightPredicates.shift(fieldCount));
       if (!reduceExpressions(join, expList, predicates)) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
index 66b0afb..2da9a35 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
@@ -29,6 +29,7 @@ import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.logical.LogicalJoin;
 import org.apache.calcite.rel.logical.LogicalSort;
 import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 
 
 /**
@@ -99,11 +100,12 @@ public class SortJoinTransposeRule extends RelOptRule {
     // We create a new sort operator on the corresponding input
     final RelNode newLeftInput;
     final RelNode newRightInput;
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     if (join.getJoinType() == JoinRelType.LEFT) {
       // If the input is already sorted and we are not reducing the number of tuples,
       // we bail out
-      if (RelMdUtil.checkInputForCollationAndLimit(join.getLeft(), sort.getCollation(),
-          sort.offset, sort.fetch)) {
+      if (RelMdUtil.checkInputForCollationAndLimit(mq, join.getLeft(),
+          sort.getCollation(), sort.offset, sort.fetch)) {
         return;
       }
       newLeftInput = sort.copy(sort.getTraitSet(), join.getLeft(), sort.getCollation(),
@@ -116,8 +118,8 @@ public class SortJoinTransposeRule extends RelOptRule {
                   -join.getLeft().getRowType().getFieldCount()));
       // If the input is already sorted and we are not reducing the number of tuples,
       // we bail out
-      if (RelMdUtil.checkInputForCollationAndLimit(join.getRight(), rightCollation,
-          sort.offset, sort.fetch)) {
+      if (RelMdUtil.checkInputForCollationAndLimit(mq, join.getRight(),
+          rightCollation, sort.offset, sort.fetch)) {
         return;
       }
       newLeftInput = join.getLeft();

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
index b195e3f..26d2106 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
@@ -23,6 +23,7 @@ import org.apache.calcite.rel.core.RelFactories;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.tools.RelBuilderFactory;
 
 import java.util.ArrayList;
@@ -93,9 +94,10 @@ public class SortUnionTransposeRule extends RelOptRule {
     // Thus we use 'ret' as a flag to identify if we have finished pushing the
     // sort past a union.
     boolean ret = true;
+    final RelMetadataQuery mq = RelMetadataQuery.instance();
     for (RelNode input : union.getInputs()) {
-      if (!RelMdUtil.checkInputForCollationAndLimit(input, sort.getCollation(),
-          sort.offset, sort.fetch)) {
+      if (!RelMdUtil.checkInputForCollationAndLimit(mq, input,
+          sort.getCollation(), sort.offset, sort.fetch)) {
         ret = false;
         Sort branchSort = sort.copy(sort.getTraitSet(), input,
             sort.getCollation(), sort.offset, sort.fetch);

http://git-wip-us.apache.org/repos/asf/calcite/blob/cabdcf44/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
index c3daf49..56b362d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
@@ -148,7 +148,8 @@ public abstract class SubQueryRemoveRule extends RelOptRule {
     switch (e.getKind()) {
     case SCALAR_QUERY:
       builder.push(e.rel);
-      final Boolean unique = RelMetadataQuery.areColumnsUnique(builder.peek(),
+      final RelMetadataQuery mq = RelMetadataQuery.instance();
+      final Boolean unique = mq.areColumnsUnique(builder.peek(),
           ImmutableBitSet.of());
       if (unique == null || !unique) {
         builder.aggregate(builder.groupKey(),


Mime
View raw message