You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by ma...@apache.org on 2015/11/11 05:06:11 UTC

[1/4] phoenix git commit: PHOENIX-1844, PHOENIX-1879

Repository: phoenix
Updated Branches:
  refs/heads/calcite ed39c7d53 -> 50e4406db


http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixConverterRules.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixConverterRules.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixConverterRules.java
index 9d83df5..84b4a60 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixConverterRules.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixConverterRules.java
@@ -44,16 +44,15 @@ import org.apache.phoenix.calcite.rel.PhoenixClientJoin;
 import org.apache.phoenix.calcite.rel.PhoenixClientProject;
 import org.apache.phoenix.calcite.rel.PhoenixClientSemiJoin;
 import org.apache.phoenix.calcite.rel.PhoenixClientSort;
+import org.apache.phoenix.calcite.rel.PhoenixConvention;
 import org.apache.phoenix.calcite.rel.PhoenixCorrelate;
 import org.apache.phoenix.calcite.rel.PhoenixFilter;
 import org.apache.phoenix.calcite.rel.PhoenixLimit;
-import org.apache.phoenix.calcite.rel.PhoenixRel;
 import org.apache.phoenix.calcite.rel.PhoenixServerAggregate;
 import org.apache.phoenix.calcite.rel.PhoenixServerJoin;
 import org.apache.phoenix.calcite.rel.PhoenixServerProject;
 import org.apache.phoenix.calcite.rel.PhoenixServerSemiJoin;
 import org.apache.phoenix.calcite.rel.PhoenixServerSort;
-import org.apache.phoenix.calcite.rel.PhoenixToClientConverter;
 import org.apache.phoenix.calcite.rel.PhoenixToEnumerableConverter;
 import org.apache.phoenix.calcite.rel.PhoenixUncollect;
 import org.apache.phoenix.calcite.rel.PhoenixUnion;
@@ -65,7 +64,7 @@ import com.google.common.collect.Lists;
 
 /**
  * Rules and relational operators for
- * {@link PhoenixRel#CONVENTION PHOENIX}
+ * {@link PhoenixConvention}
  * calling convention.
  */
 public class PhoenixConverterRules {
@@ -74,15 +73,16 @@ public class PhoenixConverterRules {
     protected static final Logger LOGGER = CalciteTrace.getPlannerTracer();
 
     public static final RelOptRule[] RULES = {
-        PhoenixToEnumerableConverterRule.INSTANCE,
-        PhoenixServerToClientConverterRule.INSTANCE,
-        PhoenixProjectableToClientConverterRule.INSTANCE,
+        PhoenixToEnumerableConverterRule.SERVER,
+        PhoenixToEnumerableConverterRule.SERVERJOIN,
+        PhoenixToEnumerableConverterRule.CLIENT,
         PhoenixClientSortRule.INSTANCE,
         PhoenixServerSortRule.SERVER,
         PhoenixServerSortRule.SERVERJOIN,
         PhoenixLimitRule.INSTANCE,
         PhoenixFilterRule.INSTANCE,
-        PhoenixClientProjectRule.INSTANCE,
+        PhoenixClientProjectRule.SERVERJOIN,
+        PhoenixClientProjectRule.CLIENT,
         PhoenixServerProjectRule.INSTANCE,
         PhoenixClientAggregateRule.INSTANCE,
         PhoenixServerAggregateRule.SERVER,
@@ -98,15 +98,16 @@ public class PhoenixConverterRules {
     };
 
     public static final RelOptRule[] CONVERTIBLE_RULES = {
-        PhoenixToEnumerableConverterRule.INSTANCE,
-        PhoenixServerToClientConverterRule.INSTANCE,
-        PhoenixProjectableToClientConverterRule.INSTANCE,
+        PhoenixToEnumerableConverterRule.SERVER,
+        PhoenixToEnumerableConverterRule.SERVERJOIN,
+        PhoenixToEnumerableConverterRule.CLIENT,
         PhoenixClientSortRule.INSTANCE,
         PhoenixServerSortRule.SERVER,
         PhoenixServerSortRule.SERVERJOIN,
         PhoenixLimitRule.INSTANCE,
         PhoenixFilterRule.CONVERTIBLE,
-        PhoenixClientProjectRule.CONVERTIBLE,
+        PhoenixClientProjectRule.CONVERTIBLE_SERVERJOIN,
+        PhoenixClientProjectRule.CONVERTIBLE_CLIENT,
         PhoenixServerProjectRule.CONVERTIBLE,
         PhoenixClientAggregateRule.CONVERTIBLE,
         PhoenixServerAggregateRule.CONVERTIBLE_SERVER,
@@ -165,7 +166,7 @@ public class PhoenixConverterRules {
         private PhoenixClientSortRule() {
             super(LogicalSort.class, 
                     SORT_ONLY, 
-                    Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixClientSortRule");
+                    Convention.NONE, PhoenixConvention.CLIENT, "PhoenixClientSortRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -173,7 +174,7 @@ public class PhoenixConverterRules {
             return PhoenixClientSort.create(
                 convert(
                         sort.getInput(), 
-                        sort.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                        sort.getInput().getTraitSet().replace(PhoenixConvention.CLIENT)),
                 sort.getCollation());
         }
     }
@@ -193,15 +194,15 @@ public class PhoenixConverterRules {
             }            
         };
         
-        public static final PhoenixServerSortRule SERVER = new PhoenixServerSortRule(PhoenixRel.SERVER_CONVENTION);
-        public static final PhoenixServerSortRule SERVERJOIN = new PhoenixServerSortRule(PhoenixRel.SERVERJOIN_CONVENTION);
+        public static final PhoenixServerSortRule SERVER = new PhoenixServerSortRule(PhoenixConvention.SERVER);
+        public static final PhoenixServerSortRule SERVERJOIN = new PhoenixServerSortRule(PhoenixConvention.SERVERJOIN);
 
         private final Convention inputConvention;
 
         private PhoenixServerSortRule(Convention inputConvention) {
             super(LogicalSort.class, 
                     SORT_ONLY, 
-                    Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixServerSortRule:" + inputConvention.getName());
+                    Convention.NONE, PhoenixConvention.CLIENT, "PhoenixServerSortRule:" + inputConvention.getName());
             this.inputConvention = inputConvention;
         }
 
@@ -234,7 +235,7 @@ public class PhoenixConverterRules {
         private PhoenixLimitRule() {
             super(LogicalSort.class, 
                     HAS_FETCH, 
-                    Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixLimitRule");
+                    Convention.NONE, PhoenixConvention.CLIENT, "PhoenixLimitRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -250,7 +251,7 @@ public class PhoenixConverterRules {
             return PhoenixLimit.create(
                 convert(
                         input, 
-                        input.getTraitSet().replace(out)),
+                        input.getTraitSet().replace(PhoenixConvention.GENERIC)),
                 sort.offset, 
                 sort.fetch);
         }
@@ -274,7 +275,7 @@ public class PhoenixConverterRules {
 
         private PhoenixFilterRule(Predicate<LogicalFilter> predicate) {
             super(LogicalFilter.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixFilterRule");
+                    PhoenixConvention.CLIENT, "PhoenixFilterRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -282,7 +283,7 @@ public class PhoenixConverterRules {
             return PhoenixFilter.create(
                 convert(
                         filter.getInput(), 
-                        filter.getInput().getTraitSet().replace(out)),
+                        filter.getInput().getTraitSet().replace(PhoenixConvention.GENERIC)),
                 filter.getCondition());
         }
     }
@@ -300,13 +301,30 @@ public class PhoenixConverterRules {
             }            
         };
         
-        private static final PhoenixClientProjectRule INSTANCE = new PhoenixClientProjectRule(Predicates.<LogicalProject>alwaysTrue());
-
-        private static final PhoenixClientProjectRule CONVERTIBLE = new PhoenixClientProjectRule(IS_CONVERTIBLE);
+        private static final PhoenixClientProjectRule SERVERJOIN =
+                new PhoenixClientProjectRule(
+                        Predicates.<LogicalProject>alwaysTrue(),
+                        PhoenixConvention.SERVERJOIN);
+        private static final PhoenixClientProjectRule CLIENT =
+                new PhoenixClientProjectRule(
+                        Predicates.<LogicalProject>alwaysTrue(),
+                        PhoenixConvention.CLIENT);
+        private static final PhoenixClientProjectRule CONVERTIBLE_SERVERJOIN =
+                new PhoenixClientProjectRule(
+                        IS_CONVERTIBLE,
+                        PhoenixConvention.SERVERJOIN);
+        private static final PhoenixClientProjectRule CONVERTIBLE_CLIENT =
+                new PhoenixClientProjectRule(
+                        IS_CONVERTIBLE,
+                        PhoenixConvention.CLIENT);
+        
+        private final Convention inputConvention;
 
-        private PhoenixClientProjectRule(Predicate<LogicalProject> predicate) {
+        private PhoenixClientProjectRule(Predicate<LogicalProject> predicate, Convention inputConvention) {
             super(LogicalProject.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixClientProjectRule");
+                    PhoenixConvention.CLIENT,
+                    "PhoenixClientProjectRule:" + inputConvention);
+            this.inputConvention = inputConvention;
         }
 
         public RelNode convert(RelNode rel) {
@@ -314,7 +332,7 @@ public class PhoenixConverterRules {
             return PhoenixClientProject.create(
                 convert(
                         project.getInput(), 
-                        project.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), 
+                        project.getInput().getTraitSet().replace(inputConvention)), 
                 project.getProjects(),
                 project.getRowType());
         }
@@ -339,7 +357,7 @@ public class PhoenixConverterRules {
 
         private PhoenixServerProjectRule(Predicate<LogicalProject> predicate) {
             super(LogicalProject.class, predicate, Convention.NONE, 
-                    PhoenixRel.SERVER_CONVENTION, "PhoenixServerProjectRule");
+                    PhoenixConvention.SERVER, "PhoenixServerProjectRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -347,7 +365,7 @@ public class PhoenixConverterRules {
             return PhoenixServerProject.create(
                 convert(
                         project.getInput(), 
-                        project.getInput().getTraitSet().replace(PhoenixRel.SERVER_CONVENTION)), 
+                        project.getInput().getTraitSet().replace(PhoenixConvention.SERVER)), 
                 project.getProjects(),
                 project.getRowType());
         }
@@ -372,7 +390,7 @@ public class PhoenixConverterRules {
 
         private PhoenixClientAggregateRule(Predicate<LogicalAggregate> predicate) {
             super(LogicalAggregate.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixClientAggregateRule");
+                    PhoenixConvention.CLIENT, "PhoenixClientAggregateRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -380,7 +398,7 @@ public class PhoenixConverterRules {
             return PhoenixClientAggregate.create(
                     convert(
                             agg.getInput(), 
-                            agg.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            agg.getInput().getTraitSet().replace(PhoenixConvention.CLIENT)),
                     agg.indicator,
                     agg.getGroupSet(),
                     agg.getGroupSets(),
@@ -401,17 +419,17 @@ public class PhoenixConverterRules {
             }            
         };
         
-        public static final RelOptRule SERVER = new PhoenixServerAggregateRule(Predicates.<LogicalAggregate>alwaysTrue(), PhoenixRel.SERVER_CONVENTION);
-        public static final RelOptRule SERVERJOIN = new PhoenixServerAggregateRule(Predicates.<LogicalAggregate>alwaysTrue(), PhoenixRel.SERVERJOIN_CONVENTION);
+        public static final RelOptRule SERVER = new PhoenixServerAggregateRule(Predicates.<LogicalAggregate>alwaysTrue(), PhoenixConvention.SERVER);
+        public static final RelOptRule SERVERJOIN = new PhoenixServerAggregateRule(Predicates.<LogicalAggregate>alwaysTrue(), PhoenixConvention.SERVERJOIN);
 
-        public static final RelOptRule CONVERTIBLE_SERVER = new PhoenixServerAggregateRule(IS_CONVERTIBLE, PhoenixRel.SERVER_CONVENTION);
-        public static final RelOptRule CONVERTIBLE_SERVERJOIN = new PhoenixServerAggregateRule(IS_CONVERTIBLE, PhoenixRel.SERVERJOIN_CONVENTION);
+        public static final RelOptRule CONVERTIBLE_SERVER = new PhoenixServerAggregateRule(IS_CONVERTIBLE, PhoenixConvention.SERVER);
+        public static final RelOptRule CONVERTIBLE_SERVERJOIN = new PhoenixServerAggregateRule(IS_CONVERTIBLE, PhoenixConvention.SERVERJOIN);
         
         private final Convention inputConvention;
 
         private PhoenixServerAggregateRule(Predicate<LogicalAggregate> predicate, Convention inputConvention) {
             super(LogicalAggregate.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixServerAggregateRule:" + inputConvention.getName());
+                    PhoenixConvention.CLIENT, "PhoenixServerAggregateRule:" + inputConvention.getName());
             this.inputConvention = inputConvention;
         }
 
@@ -446,13 +464,13 @@ public class PhoenixConverterRules {
 
         private PhoenixUnionRule(Predicate<LogicalUnion> predicate) {
             super(LogicalUnion.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixUnionRule");
+                    PhoenixConvention.CLIENT, "PhoenixUnionRule");
         }
 
         public RelNode convert(RelNode rel) {
             final LogicalUnion union = (LogicalUnion) rel;
             return PhoenixUnion.create(
-                    convertList(union.getInputs(), out),
+                    convertList(union.getInputs(), PhoenixConvention.GENERIC),
                     union.all);
         }
     }
@@ -483,7 +501,7 @@ public class PhoenixConverterRules {
 
         private PhoenixClientJoinRule(Predicate<LogicalJoin> predicate) {
             super(LogicalJoin.class, predicate, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixClientJoinRule");
+                    PhoenixConvention.CLIENT, "PhoenixClientJoinRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -511,10 +529,10 @@ public class PhoenixConverterRules {
             return PhoenixClientJoin.create(
                     convert(
                             left, 
-                            left.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            left.getTraitSet().replace(PhoenixConvention.GENERIC)),
                     convert(
                             right, 
-                            right.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            right.getTraitSet().replace(PhoenixConvention.GENERIC)),
                     join.getCondition(),
                     join.getJoinType(),
                     join.getVariablesStopped(),
@@ -548,7 +566,7 @@ public class PhoenixConverterRules {
 
         private PhoenixServerJoinRule(Predicate<LogicalJoin> predicate) {
             super(LogicalJoin.class, predicate, Convention.NONE, 
-                    PhoenixRel.SERVERJOIN_CONVENTION, "PhoenixServerJoinRule");
+                    PhoenixConvention.SERVERJOIN, "PhoenixServerJoinRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -556,10 +574,10 @@ public class PhoenixConverterRules {
             return PhoenixServerJoin.create(
                     convert(
                             join.getLeft(), 
-                            join.getLeft().getTraitSet().replace(PhoenixRel.SERVER_CONVENTION)),
+                            join.getLeft().getTraitSet().replace(PhoenixConvention.SERVER)),
                     convert(
                             join.getRight(), 
-                            join.getRight().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            join.getRight().getTraitSet().replace(PhoenixConvention.GENERIC)),
                     join.getCondition(),
                     join.getJoinType(),
                     join.getVariablesStopped(),
@@ -577,7 +595,7 @@ public class PhoenixConverterRules {
 
         private PhoenixClientSemiJoinRule() {
             super(SemiJoin.class, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixClientSemiJoinRule");
+                    PhoenixConvention.CLIENT, "PhoenixClientSemiJoinRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -605,10 +623,10 @@ public class PhoenixConverterRules {
             return PhoenixClientSemiJoin.create(
                     convert(
                             left, 
-                            left.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            left.getTraitSet().replace(PhoenixConvention.GENERIC)),
                     convert(
                             right, 
-                            right.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            right.getTraitSet().replace(PhoenixConvention.GENERIC)),
                     join.getCondition());
         }
     }
@@ -623,7 +641,7 @@ public class PhoenixConverterRules {
 
         private PhoenixServerSemiJoinRule() {
             super(SemiJoin.class, Convention.NONE, 
-                    PhoenixRel.SERVERJOIN_CONVENTION, "PhoenixServerSemiJoinRule");
+                    PhoenixConvention.SERVERJOIN, "PhoenixServerSemiJoinRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -631,10 +649,10 @@ public class PhoenixConverterRules {
             return PhoenixServerSemiJoin.create(
                     convert(
                             join.getLeft(), 
-                            join.getLeft().getTraitSet().replace(PhoenixRel.SERVER_CONVENTION)),
+                            join.getLeft().getTraitSet().replace(PhoenixConvention.SERVER)),
                     convert(
                             join.getRight(), 
-                            join.getRight().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)),
+                            join.getRight().getTraitSet().replace(PhoenixConvention.GENERIC)),
                     join.getCondition());
         }
     }
@@ -647,7 +665,7 @@ public class PhoenixConverterRules {
         public static PhoenixValuesRule INSTANCE = new PhoenixValuesRule();
         
         private PhoenixValuesRule() {
-            super(LogicalValues.class, Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixValuesRule");
+            super(LogicalValues.class, Convention.NONE, PhoenixConvention.CLIENT, "PhoenixValuesRule");
         }
 
         @Override public RelNode convert(RelNode rel) {
@@ -669,7 +687,7 @@ public class PhoenixConverterRules {
 
         private PhoenixUncollectRule() {
             super(Uncollect.class, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixUncollectRule");
+                    PhoenixConvention.CLIENT, "PhoenixUncollectRule");
         }
 
         public RelNode convert(RelNode rel) {
@@ -677,7 +695,7 @@ public class PhoenixConverterRules {
             return PhoenixUncollect.create(
                 convert(
                         uncollect.getInput(), 
-                        uncollect.getInput().getTraitSet().replace(out)));
+                        uncollect.getInput().getTraitSet().replace(PhoenixConvention.GENERIC)));
         }
     }
 
@@ -691,16 +709,16 @@ public class PhoenixConverterRules {
 
         private PhoenixCorrelateRule() {
             super(LogicalCorrelate.class, Convention.NONE, 
-                    PhoenixRel.CLIENT_CONVENTION, "PhoenixCorrelateRule");
+                    PhoenixConvention.CLIENT, "PhoenixCorrelateRule");
         }
 
         public RelNode convert(RelNode rel) {
             final Correlate correlate = (Correlate) rel;
             return PhoenixCorrelate.create(
                 convert(correlate.getLeft(), 
-                        correlate.getLeft().getTraitSet().replace(out)),
+                        correlate.getLeft().getTraitSet().replace(PhoenixConvention.GENERIC)),
                 convert(correlate.getRight(), 
-                        correlate.getRight().getTraitSet().replace(out)),
+                        correlate.getRight().getTraitSet().replace(PhoenixConvention.GENERIC)),
                 correlate.getCorrelationId(),
                 correlate.getRequiredColumns(),
                 correlate.getJoinType());
@@ -809,57 +827,24 @@ public class PhoenixConverterRules {
      }
      }
      */
+    
 
     /**
      * Rule to convert a relational expression from
-     * {@link org.apache.phoenix.calcite.rel.PhoenixRel#SERVER_CONVENTION} to
-     * {@link org.apache.phoenix.calcite.rel.PhoenixRel#CLIENT_CONVENTION}.
-     */
-    public static class PhoenixServerToClientConverterRule extends ConverterRule {
-        public static final ConverterRule INSTANCE =
-            new PhoenixServerToClientConverterRule();
-
-        private PhoenixServerToClientConverterRule() {
-            super(RelNode.class, PhoenixRel.SERVER_CONVENTION, PhoenixRel.CLIENT_CONVENTION,
-                "PhoenixServerToClientConverterRule");
-        }
-
-        @Override public RelNode convert(RelNode rel) {
-            return PhoenixToClientConverter.create(rel);
-        }
-    }
-
-    /**
-     * Rule to convert a relational expression from
-     * {@link org.apache.phoenix.calcite.rel.PhoenixRel#SERVERJOIN_CONVENTION} to
-     * {@link org.apache.phoenix.calcite.rel.PhoenixRel#CLIENT_CONVENTION}.
-     */
-    public static class PhoenixProjectableToClientConverterRule extends ConverterRule {
-        public static final ConverterRule INSTANCE =
-            new PhoenixProjectableToClientConverterRule();
-
-        private PhoenixProjectableToClientConverterRule() {
-            super(RelNode.class, PhoenixRel.SERVERJOIN_CONVENTION, PhoenixRel.CLIENT_CONVENTION,
-                "PhoenixProjectableToClientConverterRule");
-        }
-
-        @Override public RelNode convert(RelNode rel) {
-            return PhoenixToClientConverter.create(rel);
-        }
-    }
-
-    /**
-     * Rule to convert a relational expression from
-     * {@link org.apache.phoenix.calcite.rel.PhoenixRel#CONVENTION} to
+     * {@link org.apache.phoenix.calcite.rel.PhoenixConvention} to
      * {@link org.apache.calcite.adapter.enumerable.EnumerableConvention}.
      */
     public static class PhoenixToEnumerableConverterRule extends ConverterRule {
-        public static final ConverterRule INSTANCE =
-            new PhoenixToEnumerableConverterRule();
-
-        private PhoenixToEnumerableConverterRule() {
-            super(RelNode.class, PhoenixRel.CLIENT_CONVENTION, EnumerableConvention.INSTANCE,
-                "PhoenixToEnumerableConverterRule");
+        public static final ConverterRule SERVER =
+                new PhoenixToEnumerableConverterRule(PhoenixConvention.SERVER);
+        public static final ConverterRule SERVERJOIN =
+                new PhoenixToEnumerableConverterRule(PhoenixConvention.SERVERJOIN);
+        public static final ConverterRule CLIENT =
+                new PhoenixToEnumerableConverterRule(PhoenixConvention.CLIENT);
+
+        private PhoenixToEnumerableConverterRule(Convention inputConvention) {
+            super(RelNode.class, inputConvention, EnumerableConvention.INSTANCE,
+                "PhoenixToEnumerableConverterRule:" + inputConvention);
         }
 
         @Override public RelNode convert(RelNode rel) {

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixFilterScanMergeRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixFilterScanMergeRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixFilterScanMergeRule.java
index ba303a6..a6f3a59 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixFilterScanMergeRule.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixFilterScanMergeRule.java
@@ -5,16 +5,19 @@ import com.google.common.base.Predicate;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.phoenix.calcite.rel.PhoenixTableScan;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan.ScanOrder;
 
 public class PhoenixFilterScanMergeRule extends RelOptRule {
 
-    /** Predicate that returns true if a table scan has no filter. */
-    private static final Predicate<PhoenixTableScan> NO_FILTER =
+    /** Predicate that returns true if a table scan has no filter and is not reverse scan. */
+    private static final Predicate<PhoenixTableScan> APPLICABLE_TABLE_SCAN =
             new Predicate<PhoenixTableScan>() {
         @Override
         public boolean apply(PhoenixTableScan phoenixTableScan) {
-            return phoenixTableScan.filter == null;
+            return phoenixTableScan.filter == null
+                    && phoenixTableScan.scanOrder != ScanOrder.REVERSE;
         }
     };
 
@@ -31,16 +34,16 @@ public class PhoenixFilterScanMergeRule extends RelOptRule {
 
     private PhoenixFilterScanMergeRule() {
         super(
-            operand(Filter.class, null, IS_CONVERTIBLE,
-                operand(PhoenixTableScan.class, null, NO_FILTER, any())));
+            operand(LogicalFilter.class, null, IS_CONVERTIBLE,
+                operand(PhoenixTableScan.class, null, APPLICABLE_TABLE_SCAN, any())));
     }
 
     @Override
     public void onMatch(RelOptRuleCall call) {
-        Filter filter = call.rel(0);
+        LogicalFilter filter = call.rel(0);
         PhoenixTableScan scan = call.rel(1);
         assert scan.filter == null : "predicate should have ensured no filter";
         call.transformTo(PhoenixTableScan.create(
-                scan.getCluster(), scan.getTable(), filter.getCondition()));
+                scan.getCluster(), scan.getTable(), filter.getCondition(), scan.scanOrder));
     }
 }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixForwardTableScanRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixForwardTableScanRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixForwardTableScanRule.java
new file mode 100644
index 0000000..b38324c
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixForwardTableScanRule.java
@@ -0,0 +1,58 @@
+package org.apache.phoenix.calcite.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Sort;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan.ScanOrder;
+
+import com.google.common.base.Predicate;
+
+public class PhoenixForwardTableScanRule extends RelOptRule {
+    private static final Predicate<Sort> NON_EMPTY_COLLATION =
+            new Predicate<Sort>() {
+        @Override
+        public boolean apply(Sort input) {
+            return !input.getCollation().getFieldCollations().isEmpty();
+        }
+    };
+    
+    private static final Predicate<PhoenixTableScan> APPLICABLE_TABLE_SCAN =
+            new Predicate<PhoenixTableScan>() {
+        @Override
+        public boolean apply(PhoenixTableScan input) {
+            return input.scanOrder == ScanOrder.NONE;
+        }
+    };
+
+    public PhoenixForwardTableScanRule(Class<? extends Sort> sortClass) {
+        super(operand(sortClass, null, NON_EMPTY_COLLATION,
+                operand(PhoenixTableScan.class, null, APPLICABLE_TABLE_SCAN, any())),
+            PhoenixForwardTableScanRule.class.getName() + ":" + sortClass.getName());
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call) {
+        final Sort sort = call.rel(0);
+        final PhoenixTableScan scan = call.rel(1);
+        final RelCollation collation = sort.getCollation();
+        assert !collation.getFieldCollations().isEmpty();
+        for (RelCollation candidate : scan.getTable().getCollationList()) {
+            if (candidate.satisfies(collation)) {
+                RelNode newRel = PhoenixTableScan.create(
+                        scan.getCluster(), scan.getTable(), scan.filter, ScanOrder.FORWARD);
+                if (sort.offset != null || sort.fetch != null) {
+                    newRel = sort.copy(
+                            sort.getTraitSet().replace(RelCollations.EMPTY),
+                            newRel, RelCollations.EMPTY, sort.offset, sort.fetch);
+                }
+                call.transformTo(newRel);
+                break;
+            }
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixJoinSingleValueAggregateMergeRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixJoinSingleValueAggregateMergeRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixJoinSingleValueAggregateMergeRule.java
index a3a1d63..bf010ce 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixJoinSingleValueAggregateMergeRule.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixJoinSingleValueAggregateMergeRule.java
@@ -6,6 +6,7 @@ import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.phoenix.calcite.rel.PhoenixAbstractAggregate;
 import org.apache.phoenix.calcite.rel.PhoenixAbstractJoin;
+import org.apache.phoenix.calcite.rel.PhoenixConvention;
 import org.apache.phoenix.calcite.rel.PhoenixRel;
 
 import com.google.common.base.Predicate;
@@ -60,7 +61,7 @@ public class PhoenixJoinSingleValueAggregateMergeRule extends RelOptRule {
         }
         
         call.transformTo(join.copy(join.getTraitSet(), join.getCondition(), 
-                left, convert(right.getInput(), right.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), join.getJoinType(), false, true));
+                left, convert(right.getInput(), right.getInput().getTraitSet().replace(PhoenixConvention.GENERIC)), join.getJoinType(), false, true));
     }
 
 }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixOrderedAggregateRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixOrderedAggregateRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixOrderedAggregateRule.java
index 286d58d..25d7138 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixOrderedAggregateRule.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixOrderedAggregateRule.java
@@ -5,25 +5,24 @@ import java.util.List;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.rel.RelCollation;
-import org.apache.calcite.rel.RelCollationTraitDef;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.logical.LogicalSort;
 import org.apache.phoenix.calcite.rel.PhoenixAbstractAggregate;
-import org.apache.phoenix.calcite.rel.PhoenixRel;
 
 import com.google.common.base.Predicate;
+import com.google.common.collect.Lists;
 
 /**
  * Phoenix rule that transforms an unordered Aggregate into an ordered Aggregate.
  * 
- * The Aggregate's child could have a collation that matches the groupSet and thus
- * makes the Aggregate ordered, but the Aggregate wouldn't know this matching 
- * collation if its child resides in a RelSubset with an empty collation.
- * An option would be to use conversion rules that create a subset of a specific
- * collation. But since there are so many potential collations that can match the
- * groupSet and most of them are meaningless for the actual child expression, we
- * do not want to make this rule a ConvertRule.
- * Instead, we surface the matching child expression by using RelOptRule and
- * reconstruct a new Aggregate with this child.
+ * An Aggregate can turn into an ordered Aggregate (stream Aggregate) if its child
+ * is ordered on the fields of the groupSet, and the collation fields can come in
+ * as an arbitrary permutation of the groupSet fields with either ascending or
+ * descending direction. That said, there could be many possible collations of a
+ * child that will qualify an ordered Aggregate, but in order to keep the search
+ * space reasonable, we will pick the most promising one(s) in this rule.
  */
 public class PhoenixOrderedAggregateRule extends RelOptRule {
     
@@ -35,43 +34,24 @@ public class PhoenixOrderedAggregateRule extends RelOptRule {
                 }
     };
     
-    private static Predicate<PhoenixRel> NON_EMPTY_COLLATION =
-            new Predicate<PhoenixRel>() {
-                @Override
-                public boolean apply(PhoenixRel input) {
-                    if (input.getConvention() != PhoenixRel.SERVER_CONVENTION
-                            && input.getConvention() != PhoenixRel.SERVERJOIN_CONVENTION)
-                        return false;
-                    
-                    List<RelCollation> collations = input.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
-                    for (RelCollation collation : collations) {
-                        if (!collation.getFieldCollations().isEmpty()) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-    };
-    
     public static final PhoenixOrderedAggregateRule INSTANCE = new PhoenixOrderedAggregateRule();
     
     public PhoenixOrderedAggregateRule() {
-        super(operand(PhoenixAbstractAggregate.class, null, UNORDERED_GROUPBY,
-                operand(PhoenixRel.class, null, NON_EMPTY_COLLATION, any())));
-    }
-    
-    @Override
-    public boolean matches(RelOptRuleCall call) {
-        PhoenixAbstractAggregate agg = call.rel(0);
-        RelNode child = call.rel(1);
-        return PhoenixAbstractAggregate.isOrderedGroupSet(agg.getGroupSet(), child);
+        super(operand(PhoenixAbstractAggregate.class, null, UNORDERED_GROUPBY, any()));
     }
 
     @Override
     public void onMatch(RelOptRuleCall call) {
         PhoenixAbstractAggregate agg = call.rel(0);
-        RelNode child = call.rel(1);
-        call.transformTo(agg.copy(agg.getTraitSet(), child, agg.indicator, agg.getGroupSet(), agg.groupSets, agg.getAggCallList()));
+        List<RelFieldCollation> fieldCollations = Lists.newArrayList();
+        for (Integer ordinal : agg.getGroupSet().asList()) {
+            fieldCollations.add(new RelFieldCollation(ordinal));
+        }
+        RelCollation collation = RelCollations.of(fieldCollations);
+        RelNode newInput = convert(
+                LogicalSort.create(agg.getInput(), collation, null, null),
+                agg.getInput().getConvention());
+        call.transformTo(agg.copy(agg.getTraitSet(), newInput, agg.indicator, agg.getGroupSet(), agg.groupSets, agg.getAggCallList()));
     }
 
 }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixReverseTableScanRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixReverseTableScanRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixReverseTableScanRule.java
new file mode 100644
index 0000000..0a6f000
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixReverseTableScanRule.java
@@ -0,0 +1,62 @@
+package org.apache.phoenix.calcite.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Sort;
+import org.apache.phoenix.calcite.CalciteUtils;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan.ScanOrder;
+
+import com.google.common.base.Predicate;
+
+public class PhoenixReverseTableScanRule extends RelOptRule {    
+    private static final Predicate<Sort> NON_EMPTY_COLLATION =
+            new Predicate<Sort>() {
+        @Override
+        public boolean apply(Sort input) {
+            return !input.getCollation().getFieldCollations().isEmpty();
+        }
+    };
+    
+    private static final Predicate<PhoenixTableScan> APPLICABLE_TABLE_SCAN =
+            new Predicate<PhoenixTableScan>() {
+        @Override
+        public boolean apply(PhoenixTableScan input) {
+            return input.scanOrder != ScanOrder.REVERSE
+                    && input.isReverseScanEnabled()
+                    && (input.scanRanges == null
+                        || !input.scanRanges.useSkipScanFilter());
+        }
+    };
+
+    public PhoenixReverseTableScanRule(Class<? extends Sort> sortClass) {
+        super(operand(sortClass, null, NON_EMPTY_COLLATION,
+                operand(PhoenixTableScan.class, null, APPLICABLE_TABLE_SCAN, any())),
+            PhoenixReverseTableScanRule.class.getName() + ":" + sortClass.getName());
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call) {
+        final Sort sort = call.rel(0);
+        final PhoenixTableScan scan = call.rel(1);
+        final RelCollation collation = sort.getCollation();
+        assert !collation.getFieldCollations().isEmpty();
+        for (RelCollation candidate : scan.getTable().getCollationList()) {
+            if (CalciteUtils.reverseCollation(candidate).satisfies(collation)) {
+                RelNode newRel = PhoenixTableScan.create(
+                        scan.getCluster(), scan.getTable(), scan.filter, ScanOrder.REVERSE);
+                if (sort.offset != null || sort.fetch != null) {
+                    newRel = sort.copy(
+                            sort.getTraitSet().replace(RelCollations.EMPTY),
+                            newRel, RelCollations.EMPTY, sort.offset, sort.fetch);
+                }
+                call.transformTo(newRel);
+                break;
+            }
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixSortServerJoinTransposeRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixSortServerJoinTransposeRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixSortServerJoinTransposeRule.java
new file mode 100644
index 0000000..cd34a3e
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixSortServerJoinTransposeRule.java
@@ -0,0 +1,65 @@
+package org.apache.phoenix.calcite.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.phoenix.calcite.rel.PhoenixConvention;
+import org.apache.phoenix.calcite.rel.PhoenixServerJoin;
+import org.apache.phoenix.calcite.rel.PhoenixServerSort;
+import org.apache.phoenix.calcite.rel.PhoenixTemporarySort;
+
+import com.google.common.base.Predicate;
+
+public class PhoenixSortServerJoinTransposeRule extends RelOptRule {
+    private static final Predicate<Join> INNER_OR_LEFT = new Predicate<Join>() {
+        @Override
+        public boolean apply(Join input) {
+            return input.getJoinType() == JoinRelType.INNER
+                    || input.getJoinType() == JoinRelType.LEFT;
+        }        
+    };
+    
+    public static final PhoenixSortServerJoinTransposeRule INSTANCE =
+            new PhoenixSortServerJoinTransposeRule();
+
+    public PhoenixSortServerJoinTransposeRule() {
+        super(operand(PhoenixServerSort.class,
+                operand(PhoenixServerJoin.class, null, INNER_OR_LEFT, any())));
+    }
+
+    @Override public boolean matches(RelOptRuleCall call) {
+        final PhoenixServerSort sort = call.rel(0);
+        final PhoenixServerJoin join = call.rel(1);
+        if (!join.getLeft().getConvention().satisfies(PhoenixConvention.SERVER)) {
+            return false;
+        }
+        for (RelFieldCollation relFieldCollation
+                : sort.getCollation().getFieldCollations()) {
+            if (relFieldCollation.getFieldIndex()
+                    >= join.getLeft().getRowType().getFieldCount()) {
+                return false;
+            }
+        }
+        if (RelMdUtil.checkInputForCollationAndLimit(
+                join.getLeft(), sort.getCollation(), null, null)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override public void onMatch(RelOptRuleCall call) {
+      final PhoenixServerSort sort = call.rel(0);
+      final PhoenixServerJoin join = call.rel(1);
+      final RelNode newLeftInput = PhoenixTemporarySort.create(
+              join.getLeft(), sort.getCollation());
+      final RelNode newRel = join.copy(join.getTraitSet(), join.getCondition(),
+              newLeftInput, join.getRight(), join.getJoinType(), join.isSemiJoinDone());
+
+      call.transformTo(newRel);
+    }
+}

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/util/ScanUtil.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/util/ScanUtil.java b/phoenix-core/src/main/java/org/apache/phoenix/util/ScanUtil.java
index c80d9c5..7b76a2b 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/util/ScanUtil.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/util/ScanUtil.java
@@ -84,8 +84,6 @@ public class ScanUtil {
         Arrays.fill(MAX_FILL_LENGTH_FOR_PREVIOUS_KEY, (byte)-1);
     }
     private static final byte[] ZERO_BYTE_ARRAY = new byte[1024];
-    
-    private static final String FORCE_ROW_KEY_ORDER = "_ForceRowKeyOrder";
 
     private ScanUtil() {
     }
@@ -736,14 +734,9 @@ public class ScanUtil {
         return fetchSize > 1 && !shouldRowsBeInRowKeyOrder(orderBy, context) && orderBy.getOrderByExpressions().isEmpty();
     }
     
-    public static void setForceRowKeyOrder(Scan scan) {
-        scan.setAttribute(FORCE_ROW_KEY_ORDER, Bytes.toBytes(Boolean.TRUE.toString()));
-    }
-    
     public static boolean forceRowKeyOrder(StatementContext context) {
-        return context.getScan().getAttribute(FORCE_ROW_KEY_ORDER) != null
-                && context.getConnection().getQueryServices().getProps()
-                    .getBoolean(QueryServices.FORCE_ROW_KEY_ORDER_ATTRIB, QueryServicesOptions.DEFAULT_FORCE_ROW_KEY_ORDER);
+        return context.getConnection().getQueryServices().getProps()
+                .getBoolean(QueryServices.FORCE_ROW_KEY_ORDER_ATTRIB, QueryServicesOptions.DEFAULT_FORCE_ROW_KEY_ORDER);
     }
     
     public static boolean shouldRowsBeInRowKeyOrder(OrderBy orderBy, StatementContext context) {

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/test/java/org/apache/phoenix/calcite/ToExpressionTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/calcite/ToExpressionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/calcite/ToExpressionTest.java
index bd239bd..3734b4c 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/calcite/ToExpressionTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/calcite/ToExpressionTest.java
@@ -165,7 +165,7 @@ public class ToExpressionTest extends BaseConnectionlessQueryTest {
                 return null;
             
             PTable table = rootTables.get(name);
-            return new PhoenixTable(pc, table, true);
+            return new PhoenixTable(pc, table);
         }
 
         @Override

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 38acce1..079c6c6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -109,7 +109,7 @@
     <collections.version>3.2.1</collections.version>
     <jodatime.version>2.7</jodatime.version>
     <joni.version>2.1.2</joni.version>
-    <calcite.version>1.5.0-incubating-SNAPSHOT</calcite.version>
+    <calcite.version>1.6.0-SNAPSHOT</calcite.version>
 
     <!-- Test Dependencies -->
     <mockito-all.version>1.8.5</mockito-all.version>


[4/4] phoenix git commit: PHOENIX-1844, PHOENIX-1879

Posted by ma...@apache.org.
PHOENIX-1844, PHOENIX-1879


Project: http://git-wip-us.apache.org/repos/asf/phoenix/repo
Commit: http://git-wip-us.apache.org/repos/asf/phoenix/commit/50e4406d
Tree: http://git-wip-us.apache.org/repos/asf/phoenix/tree/50e4406d
Diff: http://git-wip-us.apache.org/repos/asf/phoenix/diff/50e4406d

Branch: refs/heads/calcite
Commit: 50e4406dbfe33273c656077e984f1c1dcc79e903
Parents: ed39c7d
Author: maryannxue <we...@intel.com>
Authored: Tue Nov 10 23:05:46 2015 -0500
Committer: maryannxue <we...@intel.com>
Committed: Tue Nov 10 23:05:46 2015 -0500

----------------------------------------------------------------------
 .../org/apache/phoenix/calcite/CalciteIT.java   | 636 +++++++++----------
 .../apache/phoenix/calcite/CalciteUtils.java    |  26 +
 .../apache/phoenix/calcite/PhoenixSchema.java   |  46 +-
 .../apache/phoenix/calcite/PhoenixTable.java    |  27 +-
 .../calcite/jdbc/PhoenixPrepareImpl.java        |  34 +-
 .../calcite/metadata/PhoenixRelMdCollation.java |   6 +
 .../calcite/rel/PhoenixAbstractAggregate.java   |  35 +-
 .../calcite/rel/PhoenixClientAggregate.java     |   4 +-
 .../phoenix/calcite/rel/PhoenixClientJoin.java  |   6 +-
 .../calcite/rel/PhoenixClientProject.java       |   5 +-
 .../calcite/rel/PhoenixClientSemiJoin.java      |   6 +-
 .../phoenix/calcite/rel/PhoenixClientSort.java  |   4 +-
 .../calcite/rel/PhoenixCompactClientSort.java   |   4 +-
 .../phoenix/calcite/rel/PhoenixConvention.java  |  47 ++
 .../phoenix/calcite/rel/PhoenixCorrelate.java   |   8 +-
 .../phoenix/calcite/rel/PhoenixFilter.java      |   4 +-
 .../phoenix/calcite/rel/PhoenixLimit.java       |   4 +-
 .../calcite/rel/PhoenixMergeSortUnion.java      |   4 +-
 .../apache/phoenix/calcite/rel/PhoenixRel.java  |   7 +-
 .../calcite/rel/PhoenixServerAggregate.java     |   6 +-
 .../phoenix/calcite/rel/PhoenixServerJoin.java  |   6 +-
 .../calcite/rel/PhoenixServerProject.java       |   4 +-
 .../calcite/rel/PhoenixServerSemiJoin.java      |   6 +-
 .../phoenix/calcite/rel/PhoenixServerSort.java  |   6 +-
 .../phoenix/calcite/rel/PhoenixTableScan.java   |  85 ++-
 .../calcite/rel/PhoenixTemporarySort.java       |  43 ++
 .../calcite/rel/PhoenixToClientConverter.java   |  45 --
 .../phoenix/calcite/rel/PhoenixUncollect.java   |   4 +-
 .../phoenix/calcite/rel/PhoenixUnion.java       |   4 +-
 .../phoenix/calcite/rel/PhoenixValues.java      |   2 +-
 .../rules/PhoenixCompactClientSortRule.java     |   9 +-
 .../calcite/rules/PhoenixConverterRules.java    | 185 +++---
 .../rules/PhoenixFilterScanMergeRule.java       |  17 +-
 .../rules/PhoenixForwardTableScanRule.java      |  58 ++
 ...hoenixJoinSingleValueAggregateMergeRule.java |   3 +-
 .../rules/PhoenixOrderedAggregateRule.java      |  60 +-
 .../rules/PhoenixReverseTableScanRule.java      |  62 ++
 .../PhoenixSortServerJoinTransposeRule.java     |  65 ++
 .../java/org/apache/phoenix/util/ScanUtil.java  |  11 +-
 .../phoenix/calcite/ToExpressionTest.java       |   2 +-
 pom.xml                                         |   2 +-
 41 files changed, 923 insertions(+), 675 deletions(-)
----------------------------------------------------------------------



[3/4] phoenix git commit: PHOENIX-1844, PHOENIX-1879

Posted by ma...@apache.org.
http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/it/java/org/apache/phoenix/calcite/CalciteIT.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/it/java/org/apache/phoenix/calcite/CalciteIT.java b/phoenix-core/src/it/java/org/apache/phoenix/calcite/CalciteIT.java
index b1720cf..2d904ef 100644
--- a/phoenix-core/src/it/java/org/apache/phoenix/calcite/CalciteIT.java
+++ b/phoenix-core/src/it/java/org/apache/phoenix/calcite/CalciteIT.java
@@ -398,8 +398,7 @@ public class CalciteIT extends BaseClientManagedTimeIT {
     @Test public void testTableScan() throws Exception {
         start(false).sql("select * from aTable where a_string = 'a'")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
+                           "  PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", "00A123122312312", "a"}, 
                           {"00D300000000XHP", "00A223122312312", "a"}, 
@@ -411,9 +410,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
     @Test public void testProject() throws Exception {
         start(false).sql("select entity_id, a_string, organization_id from aTable where a_string = 'a'")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerProject(ENTITY_ID=[$1], A_STRING=[$2], ORGANIZATION_ID=[$0])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
+                           "  PhoenixServerProject(ENTITY_ID=[$1], A_STRING=[$2], ORGANIZATION_ID=[$0])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
                 .resultIs(new Object[][] {
                           {"00A123122312312", "a", "00D300000000XHP"}, 
                           {"00A223122312312", "a", "00D300000000XHP"}, 
@@ -426,13 +424,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select t1.entity_id, t2.a_string, t1.organization_id from aTable t1 join aTable t2 on t1.entity_id = t2.entity_id and t1.organization_id = t2.organization_id where t1.a_string = 'a'") 
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(ENTITY_ID=[$4], A_STRING=[$2], ORGANIZATION_ID=[$3])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[AND(=($4, $1), =($3, $0))], joinType=[inner])\n" +
-                           "        PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
+                           "    PhoenixServerJoin(condition=[AND(=($4, $1), =($3, $0))], joinType=[inner])\n" +
+                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
+                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
                 .resultIs(new Object[][] {
                           {"00A123122312312", "a", "00D300000000XHP"}, 
                           {"00A223122312312", "a", "00D300000000XHP"}, 
@@ -443,13 +439,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("SELECT item.\"item_id\", item.name, supp.\"supplier_id\", supp.name FROM " + JOIN_ITEM_TABLE_FULL_NAME + " item JOIN " + JOIN_SUPPLIER_TABLE_FULL_NAME + " supp ON item.\"supplier_id\" = supp.\"supplier_id\"")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(item_id=[$0], NAME=[$1], supplier_id=[$3], NAME0=[$4])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
-                           "        PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "    PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
+                           "      PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000001", "T1", "0000000001", "S1"}, 
                           {"0000000002", "T2", "0000000001", "S1"}, 
@@ -462,12 +456,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("SELECT * FROM " + JOIN_ITEM_TABLE_FULL_NAME + " item JOIN " + JOIN_SUPPLIER_TABLE_FULL_NAME + " supp ON item.\"supplier_id\" = supp.\"supplier_id\" AND supp.name = 'S5'")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(item_id=[$0], NAME=[$1], PRICE=[$2], DISCOUNT1=[$3], DISCOUNT2=[$4], supplier_id=[$5], DESCRIPTION=[$6], supplier_id0=[$7], NAME0=[$8], PHONE=[$9], ADDRESS=[$10], LOC_ID=[$11])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[=($5, $7)], joinType=[inner])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1], PHONE=[$2], ADDRESS=[$3], LOC_ID=[$4], NAME5=[CAST($1):VARCHAR(2) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\"])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], filter=[=(CAST($1):VARCHAR(2) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\", 'S5')])\n")
+                           "    PhoenixServerJoin(condition=[=($5, $7)], joinType=[inner])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1], PHONE=[$2], ADDRESS=[$3], LOC_ID=[$4], NAME5=[CAST($1):VARCHAR(2) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\"])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], filter=[=(CAST($1):VARCHAR(2) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\", 'S5')])\n")
                 .resultIs(new Object[][] {
                           {"0000000005", "T5", 500, 8, 15, "0000000005", "Item T5", "0000000005", "S5", "888-888-5555", "505 YYY Street", "10005"}})
                 .close();
@@ -476,13 +468,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 + JOIN_ITEM_TABLE_FULL_NAME + " i ON o.\"item_id\" = i.\"item_id\" AND o.price = (i.price * (100 - discount2)) / 100.0 WHERE quantity < 5000")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(order_id=[$5], NAME=[$1], PRICE=[$2], DISCOUNT2=[$3], QUANTITY=[$7])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[AND(=($6, $0), =($8, $4))], joinType=[inner])\n" +
-                           "        PhoenixServerProject(item_id=[$0], NAME=[$1], PRICE=[$2], DISCOUNT2=[$4], $f7=[/(*($2, -(100, $4)), 100.0)])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(order_id=[$0], item_id=[$2], QUANTITY=[$4], PRICE7=[CAST($3):DECIMAL(17, 6)])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]], filter=[<($4, 5000)])\n")
+                           "    PhoenixServerJoin(condition=[AND(=($6, $0), =($8, $4))], joinType=[inner])\n" +
+                           "      PhoenixServerProject(item_id=[$0], NAME=[$1], PRICE=[$2], DISCOUNT2=[$4], $f7=[/(*($2, -(100, $4)), 100.0)])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                           "      PhoenixServerProject(order_id=[$0], item_id=[$2], QUANTITY=[$4], PRICE7=[CAST($3):DECIMAL(17, 6)])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, OrderTable]], filter=[<($4, 5000)])\n")
                 .resultIs(new Object[][] {
                           {"000000000000004", "T6", 600, 15, 4000}})
                 .close();
@@ -492,13 +482,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("SELECT item.\"item_id\", item.name, supp.\"supplier_id\", supp.name FROM " + JOIN_ITEM_TABLE_FULL_NAME + " item RIGHT OUTER JOIN " + JOIN_SUPPLIER_TABLE_FULL_NAME + " supp ON item.\"supplier_id\" = supp.\"supplier_id\"")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(item_id=[$2], NAME=[$3], supplier_id=[$0], NAME0=[$1])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[=($4, $0)], joinType=[left])\n" +
-                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
+                           "    PhoenixServerJoin(condition=[=($4, $0)], joinType=[left])\n" +
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n" +
+                           "      PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000001", "T1", "0000000001", "S1"}, 
                           {"0000000002", "T2", "0000000001", "S1"}, 
@@ -520,9 +508,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                            "        PhoenixServerSort(sort0=[$2], dir0=[ASC])\n" +
                            "          PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
                            "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                         {null, null, "0000000003", "S3"},
                         {null, null, "0000000004", "S4"},
@@ -539,12 +526,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(ENTITY_ID=[$1], A_STRING=[$4], ORGANIZATION_ID=[$0])\n" +
                            "    PhoenixClientJoin(condition=[AND(=($0, $2), =($1, $3))], joinType=[inner])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n" +
+                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                           {"00A123122312312", "a", "00D300000000XHP"},
                           {"00A223122312312", "a", "00D300000000XHP"},
@@ -563,13 +548,22 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("SELECT item.\"item_id\", item.name, supp.\"supplier_id\", supp.name FROM " + JOIN_ITEM_TABLE_FULL_NAME + " item JOIN " + JOIN_SUPPLIER_TABLE_FULL_NAME + " supp ON item.\"supplier_id\" = supp.\"supplier_id\" order by supp.\"supplier_id\"")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(item_id=[$2], NAME=[$3], supplier_id=[$0], NAME0=[$1])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[=($4, $0)], joinType=[inner])\n" +
-                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
+                           "    PhoenixServerJoin(condition=[=($4, $0)], joinType=[inner])\n" +
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], scanOrder=[FORWARD])\n" +
+                           "      PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
+                .close();
+        
+        // Server-join with LHS reversely sorted on order-by fields
+        start(false).sql("SELECT item.\"item_id\", item.name, supp.\"supplier_id\", supp.name FROM " + JOIN_ITEM_TABLE_FULL_NAME + " item JOIN " + JOIN_SUPPLIER_TABLE_FULL_NAME + " supp ON item.\"supplier_id\" = supp.\"supplier_id\" order by supp.\"supplier_id\" DESC")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixClientProject(item_id=[$2], NAME=[$3], supplier_id=[$0], NAME0=[$1])\n" +
+                           "    PhoenixServerJoin(condition=[=($4, $0)], joinType=[inner])\n" +
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], scanOrder=[REVERSE])\n" +
+                           "      PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
                 .close();
         
         // Join key being order-by fields with the other side sorted on order-by fields
@@ -580,9 +574,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                            "      PhoenixServerSort(sort0=[$2], dir0=[ASC])\n" +
                            "        PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
                            "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], scanOrder=[FORWARD])\n")
                 .close();
         
         start(false).sql("SELECT \"order_id\", i.name, i.price, discount2, quantity FROM " + JOIN_ORDER_TABLE_FULL_NAME + " o LEFT JOIN " 
@@ -593,12 +586,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 		   "      PhoenixClientJoin(condition=[=($1, $3)], joinType=[left])\n" +
                 		   "        PhoenixClientSort(sort0=[$1], dir0=[ASC])\n" +
                 		   "          PhoenixLimit(fetch=[2])\n" +
-                		   "            PhoenixToClientConverter\n" +
-                		   "              PhoenixServerProject(order_id=[$0], item_id=[$2], QUANTITY=[$4])\n" +
-                		   "                PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                		   "        PhoenixToClientConverter\n" +
-                		   "          PhoenixServerProject(item_id=[$0], NAME=[$1], PRICE=[$2], DISCOUNT2=[$4])\n" +
-                		   "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
+                		   "            PhoenixServerProject(order_id=[$0], item_id=[$2], QUANTITY=[$4])\n" +
+                		   "              PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                		   "        PhoenixServerProject(item_id=[$0], NAME=[$1], PRICE=[$2], DISCOUNT2=[$4])\n" +
+                		   "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]], scanOrder=[FORWARD])\n")
                 .close();
     }
     
@@ -606,15 +597,12 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select t1.entity_id, t2.a_string, t3.organization_id from aTable t1 join aTable t2 on t1.entity_id = t2.entity_id and t1.organization_id = t2.organization_id join atable t3 on t1.entity_id = t3.entity_id and t1.organization_id = t3.organization_id where t1.a_string = 'a'") 
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(ENTITY_ID=[$19], A_STRING=[$38], ORGANIZATION_ID=[$0])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "        PhoenixClientProject(ORGANIZATION_ID=[$18], ENTITY_ID=[$19], A_STRING=[$20], B_STRING=[$21], A_INTEGER=[$22], A_DATE=[$23], A_TIME=[$24], A_TIMESTAMP=[$25], X_DECIMAL=[$26], X_LONG=[$27], X_INTEGER=[$28], Y_INTEGER=[$29], A_BYTE=[$30], A_SHORT=[$31], A_FLOAT=[$32], A_DOUBLE=[$33], A_UNSIGNED_FLOAT=[$34], A_UNSIGNED_DOUBLE=[$35], ORGANIZATION_ID0=[$0], ENTITY_ID0=[$1], A_STRING0=[$2], B_STRING0=[$3], A_INTEGER0=[$4], A_DATE0=[$5], A_TIME0=[$6], A_TIMESTAMP0=[$7], X_DECIMAL0=[$8], X_LONG0=[$9], X_INTEGER0=[$10], Y_INTEGER0=[$11], A_BYTE0=[$12], A_SHORT0=[$13], A_FLOAT0=[$14], A_DOUBLE0=[$15], A_UNSIGNED_FLOAT0=[$16], A_UNSIGNED_DOUBLE0=[$17])\n" +
-                           "          PhoenixToClientConverter\n" +
-                           "            PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
-                           "              PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "              PhoenixToClientConverter\n" +
-                           "                PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
+                           "    PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
+                           "      PhoenixClientProject(ORGANIZATION_ID=[$18], ENTITY_ID=[$19], A_STRING=[$20], B_STRING=[$21], A_INTEGER=[$22], A_DATE=[$23], A_TIME=[$24], A_TIMESTAMP=[$25], X_DECIMAL=[$26], X_LONG=[$27], X_INTEGER=[$28], Y_INTEGER=[$29], A_BYTE=[$30], A_SHORT=[$31], A_FLOAT=[$32], A_DOUBLE=[$33], A_UNSIGNED_FLOAT=[$34], A_UNSIGNED_DOUBLE=[$35], ORGANIZATION_ID0=[$0], ENTITY_ID0=[$1], A_STRING0=[$2], B_STRING0=[$3], A_INTEGER0=[$4], A_DATE0=[$5], A_TIME0=[$6], A_TIMESTAMP0=[$7], X_DECIMAL0=[$8], X_LONG0=[$9], X_INTEGER0=[$10], Y_INTEGER0=[$11], A_BYTE0=[$12], A_SHORT0=[$13], A_FLOAT0=[$14], A_DOUBLE0=[$15], A_UNSIGNED_FLOAT0=[$16], A_UNSIGNED_DOUBLE0=[$17])\n" +
+                           "        PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
                 .resultIs(new Object[][] {
                           {"00A123122312312", "a", "00D300000000XHP"}, 
                           {"00A223122312312", "a", "00D300000000XHP"}, 
@@ -625,14 +613,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select t1.entity_id, t2.a_string, t3.organization_id from aTable t1 join aTable t2 on t1.entity_id = t2.entity_id and t1.organization_id = t2.organization_id join atable t3 on t1.entity_id = t3.entity_id and t1.organization_id = t3.organization_id")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(ENTITY_ID=[$19], A_STRING=[$2], ORGANIZATION_ID=[$36])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
+                           "    PhoenixServerJoin(condition=[AND(=($19, $1), =($18, $0))], joinType=[inner])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
+                           "      PhoenixServerJoin(condition=[AND(=($1, $19), =($0, $18))], joinType=[inner])\n" +
                            "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerJoin(condition=[AND(=($1, $19), =($0, $18))], joinType=[inner])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, ATABLE]])\n" +
-                           "            PhoenixToClientConverter\n" +
-                           "              PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
                 .resultIs(new Object[][] {
                           {"00A123122312312", "a", "00D300000000XHP"},
                           {"00A223122312312", "a", "00D300000000XHP"},
@@ -658,15 +643,15 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select organization_id, count(b_string) from atable group by organization_id")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{0}], EXPR$1=[COUNT($3)], isOrdered=[true])\n" +
-                           "    PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", 9L}})
                 .close();
         
-        start(false).sql("select organization_id, entity_id, count(b_string) from atable group by organization_id, entity_id")
+        start(false).sql("select organization_id, entity_id, count(b_string) from atable group by entity_id ,organization_id")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{0, 1}], EXPR$2=[COUNT($3)], isOrdered=[true])\n" +
-                           "    PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", "00A123122312312", 1L}, 
                           {"00D300000000XHP", "00A223122312312", 1L}, 
@@ -718,13 +703,12 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         
         start(false).sql("select s.name, count(\"item_id\") from " + JOIN_SUPPLIER_TABLE_FULL_NAME + " s join " + JOIN_ITEM_TABLE_FULL_NAME + " i on s.\"supplier_id\" = i.\"supplier_id\" group by s.name")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixServerAggregate(group=[{3}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
-                           "    PhoenixServerJoin(condition=[=($2, $1)], joinType=[inner])\n" +
-                           "      PhoenixServerProject(item_id=[$0], supplier_id=[$5])\n" +
+                           "  PhoenixServerAggregate(group=[{2}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
+                           "    PhoenixServerJoin(condition=[=($1, $0)], joinType=[inner])\n" +
+                           "      PhoenixServerProject(supplier_id=[$5])\n" +
                            "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "      PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"S1", 2L},
                           {"S2", 2L},
@@ -736,12 +720,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select s.\"supplier_id\", count(*) from " + JOIN_SUPPLIER_TABLE_FULL_NAME + " s join " + JOIN_ITEM_TABLE_FULL_NAME + " i on s.\"supplier_id\" = i.\"supplier_id\" group by s.\"supplier_id\"")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{0}], EXPR$1=[COUNT()], isOrdered=[true])\n" +
-                           "    PhoenixServerJoin(condition=[=($0, $2)], joinType=[inner])\n" +
+                           "    PhoenixServerJoin(condition=[=($0, $1)], joinType=[inner])\n" +
                            "      PhoenixServerProject(supplier_id=[$0])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(item_id=[$0], supplier_id=[$5])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
+                           "        PhoenixTableScan(table=[[phoenix, Join, SupplierTable]], scanOrder=[FORWARD])\n" +
+                           "      PhoenixServerProject(supplier_id=[$5])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000001", 2L},
                           {"0000000002", 2L},
@@ -763,7 +746,7 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(MYPK0=[$0], EXPR$1=[CAST(/($1, $2)):INTEGER NOT NULL])\n" +
                            "    PhoenixServerAggregate(group=[{0}], agg#0=[$SUM0($1)], agg#1=[COUNT()], isOrdered=[true])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE]])\n")
+                           "      PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                         {1, 2},
                         {2, 3},
@@ -803,9 +786,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         
         start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id, entity_id")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "  PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", "00A123122312312", "a"}, 
                           {"00D300000000XHP", "00A223122312312", "a"}, 
@@ -818,6 +800,55 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                           {"00D300000000XHP", "00C923122312312", "c"}})
                 .close();
         
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id DESC")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[REVERSE])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}, 
+                          {"00D300000000XHP", "00A423122312312", "a"}, 
+                          {"00D300000000XHP", "00A323122312312", "a"}, 
+                          {"00D300000000XHP", "00A223122312312", "a"}, 
+                          {"00D300000000XHP", "00A123122312312", "a"}})
+                .close();
+        
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id DESC, entity_id DESC")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[REVERSE])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}, 
+                          {"00D300000000XHP", "00A423122312312", "a"}, 
+                          {"00D300000000XHP", "00A323122312312", "a"}, 
+                          {"00D300000000XHP", "00A223122312312", "a"}, 
+                          {"00D300000000XHP", "00A123122312312", "a"}})
+                .close();
+
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id ASC, entity_id DESC")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixServerSort(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[DESC])\n" +
+                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}, 
+                          {"00D300000000XHP", "00A423122312312", "a"}, 
+                          {"00D300000000XHP", "00A323122312312", "a"}, 
+                          {"00D300000000XHP", "00A223122312312", "a"}, 
+                          {"00D300000000XHP", "00A123122312312", "a"}})
+                .close();
+        
         start(false).sql("select count(entity_id), a_string from atable group by a_string order by count(entity_id), a_string desc")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(EXPR$0=[$1], A_STRING=[$0])\n" +
@@ -833,13 +864,12 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select s.name, count(\"item_id\") from " + JOIN_SUPPLIER_TABLE_FULL_NAME + " s join " + JOIN_ITEM_TABLE_FULL_NAME + " i on s.\"supplier_id\" = i.\"supplier_id\" group by s.name order by count(\"item_id\"), s.name desc")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixCompactClientSort(sort0=[$1], sort1=[$0], dir0=[ASC], dir1=[DESC])\n" +
-                           "    PhoenixServerAggregate(group=[{3}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
-                           "      PhoenixServerJoin(condition=[=($2, $1)], joinType=[inner])\n" +
-                           "        PhoenixServerProject(item_id=[$0], supplier_id=[$5])\n" +
+                           "    PhoenixServerAggregate(group=[{2}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
+                           "      PhoenixServerJoin(condition=[=($1, $0)], joinType=[inner])\n" +
+                           "        PhoenixServerProject(supplier_id=[$5])\n" +
                            "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"S6", 1L},
                           {"S5", 1L},
@@ -854,9 +884,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                            "      PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
                            "        PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
                            "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000006", "T6", "0000000006", "S6"}, 
                           {"0000000005", "T5", "0000000005", "S5"}, 
@@ -885,9 +914,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id, entity_id limit 5")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixLimit(fetch=[5])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", "00A123122312312", "a"}, 
                           {"00D300000000XHP", "00A223122312312", "a"}, 
@@ -896,6 +924,46 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                           {"00D300000000XHP", "00B523122312312", "b"}})
                 .close();
         
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id DESC limit 5")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixLimit(fetch=[5])\n" +
+                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[REVERSE])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}})
+                .close();
+        
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id DESC, entity_id DESC limit 5")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixLimit(fetch=[5])\n" +
+                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[REVERSE])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}})
+                .close();
+
+        start(false).sql("select organization_id, entity_id, a_string from aTable order by organization_id ASC, entity_id DESC limit 5")
+                .explainIs("PhoenixToEnumerableConverter\n" +
+                           "  PhoenixLimit(fetch=[5])\n" +
+                           "    PhoenixServerSort(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[DESC])\n" +
+                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                .resultIs(new Object[][] {
+                          {"00D300000000XHP", "00C923122312312", "c"},
+                          {"00D300000000XHP", "00B823122312312", "b"}, 
+                          {"00D300000000XHP", "00B723122312312", "b"}, 
+                          {"00D300000000XHP", "00B623122312312", "b"}, 
+                          {"00D300000000XHP", "00B523122312312", "b"}})
+                .close();
+        
         start(false).sql("select count(entity_id), a_string from atable group by a_string order by count(entity_id), a_string desc limit 2")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(EXPR$0=[$1], A_STRING=[$0])\n" +
@@ -912,13 +980,12 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixLimit(fetch=[3])\n" +
                            "    PhoenixCompactClientSort(sort0=[$1], sort1=[$0], dir0=[ASC], dir1=[DESC])\n" +
-                           "      PhoenixServerAggregate(group=[{3}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
-                           "        PhoenixServerJoin(condition=[=($2, $1)], joinType=[inner])\n" +
-                           "          PhoenixServerProject(item_id=[$0], supplier_id=[$5])\n" +
+                           "      PhoenixServerAggregate(group=[{2}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
+                           "        PhoenixServerJoin(condition=[=($1, $0)], joinType=[inner])\n" +
+                           "          PhoenixServerProject(supplier_id=[$5])\n" +
                            "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "          PhoenixToClientConverter\n" +
-                           "            PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "              PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"S6", 1L},
                           {"S5", 1L},
@@ -933,9 +1000,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                            "        PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
                            "          PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
                            "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "          PhoenixToClientConverter\n" +
-                           "            PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "              PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000006", "T6", "0000000006", "S6"}, 
                           {"0000000005", "T5", "0000000005", "S5"}, 
@@ -947,9 +1013,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select organization_id, entity_id, a_string from aTable limit 5")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixLimit(fetch=[5])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                           "    PhoenixServerProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_STRING=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
                 .resultIs(new Object[][] {
                           {"00D300000000XHP", "00A123122312312", "a"}, 
                           {"00D300000000XHP", "00A223122312312", "a"}, 
@@ -972,13 +1037,12 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select s.name, count(\"item_id\") from " + JOIN_SUPPLIER_TABLE_FULL_NAME + " s join " + JOIN_ITEM_TABLE_FULL_NAME + " i on s.\"supplier_id\" = i.\"supplier_id\" group by s.name limit 3")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixLimit(fetch=[3])\n" +
-                           "    PhoenixServerAggregate(group=[{3}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
-                           "      PhoenixServerJoin(condition=[=($2, $1)], joinType=[inner])\n" +
-                           "        PhoenixServerProject(item_id=[$0], supplier_id=[$5])\n" +
+                           "    PhoenixServerAggregate(group=[{2}], EXPR$1=[COUNT()], isOrdered=[false])\n" +
+                           "      PhoenixServerJoin(condition=[=($1, $0)], joinType=[inner])\n" +
+                           "        PhoenixServerProject(supplier_id=[$5])\n" +
                            "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"S1", 2L},
                           {"S2", 2L},
@@ -989,13 +1053,11 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(item_id=[$0], NAME=[$1], supplier_id=[$3], NAME0=[$4])\n" +
                            "    PhoenixLimit(fetch=[3])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
-                           "          PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                           "          PhoenixToClientConverter\n" +
-                           "            PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
-                           "              PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
+                           "      PhoenixServerJoin(condition=[=($2, $3)], joinType=[inner])\n" +
+                           "        PhoenixServerProject(item_id=[$0], NAME=[$1], supplier_id=[$5])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                           "        PhoenixServerProject(supplier_id=[$0], NAME=[$1])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, Join, SupplierTable]])\n")
                 .resultIs(new Object[][] {
                           {"0000000001", "T1", "0000000001", "S1"}, 
                           {"0000000002", "T2", "0000000001", "S1"}, 
@@ -1017,15 +1079,13 @@ public class CalciteIT extends BaseClientManagedTimeIT {
             + "from " + JOIN_ITEM_TABLE_FULL_NAME + " i")
             .explainIs("PhoenixToEnumerableConverter\n" +
                        "  PhoenixClientProject(item_id=[$0], NAME=[$1], EXPR$2=[$8])\n" +
-                       "    PhoenixToClientConverter\n" +
-                       "      PhoenixServerJoin(condition=[=($0, $7)], joinType=[left], isSingleValueRhs=[true])\n" +
-                       "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                       "        PhoenixServerAggregate(group=[{0}], SQ=[MAX($5)], isOrdered=[true])\n" +
-                       "          PhoenixServerJoin(condition=[=($3, $0)], joinType=[inner])\n" +
-                       "            PhoenixServerProject(item_id=[$0])\n" +
-                       "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                       "            PhoenixToClientConverter\n" +
-                       "              PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n")
+                       "    PhoenixServerJoin(condition=[=($0, $7)], joinType=[left], isSingleValueRhs=[true])\n" +
+                       "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                       "      PhoenixServerAggregate(group=[{0}], SQ=[MAX($5)], isOrdered=[true])\n" +
+                       "        PhoenixServerJoin(condition=[=($3, $0)], joinType=[inner])\n" +
+                       "          PhoenixServerProject(item_id=[$0])\n" +
+                       "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]], scanOrder=[FORWARD])\n" +
+                       "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n")
             .resultIs(new Object[][] {
                     new Object[] {"0000000001", "T1", 1000},
                     new Object[] {"0000000002", "T2", 3000},
@@ -1041,16 +1101,13 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                     + "from " + JOIN_ITEM_TABLE_FULL_NAME + " i where \"item_id\" < '0000000006'")
                .explainIs("PhoenixToEnumerableConverter\n" +
                           "  PhoenixClientProject(item_id=[$0], NAME=[$1], EXPR$2=[$8])\n" +
-                          "    PhoenixToClientConverter\n" +
-                          "      PhoenixServerJoin(condition=[=($0, $7)], joinType=[left], isSingleValueRhs=[true])\n" +
-                          "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<($0, '0000000006')])\n" +
-                          "        PhoenixClientProject(item_id0=[$7], SQ=[$4])\n" +
-                          "          PhoenixToClientConverter\n" +
-                          "            PhoenixServerJoin(condition=[=($2, $7)], joinType=[inner])\n" +
-                          "              PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                          "              PhoenixToClientConverter\n" +
-                          "                PhoenixServerProject(item_id=[$0])\n" +
-                          "                  PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<($0, '0000000006')])\n")
+                          "    PhoenixServerJoin(condition=[=($0, $7)], joinType=[left], isSingleValueRhs=[true])\n" +
+                          "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<($0, '0000000006')])\n" +
+                          "      PhoenixClientProject(item_id0=[$7], SQ=[$4])\n" +
+                          "        PhoenixServerJoin(condition=[=($2, $7)], joinType=[inner])\n" +
+                          "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                          "          PhoenixServerProject(item_id=[$0])\n" +
+                          "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<($0, '0000000006')])\n")
                .resultIs(new Object[][] {
                          new Object[] {"0000000001", "T1", 1000},
                          new Object[] {"0000000002", "T2", 3000},
@@ -1063,27 +1120,23 @@ public class CalciteIT extends BaseClientManagedTimeIT {
     @Test public void testIndex() {
         start(true).sql("select * from aTable where b_string = 'b'")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                   "  PhoenixToClientConverter\n" +
-                   "    PhoenixServerProject(ORGANIZATION_ID=[$1], ENTITY_ID=[$2], A_STRING=[$3], B_STRING=[$0], A_INTEGER=[$4], A_DATE=[$5], A_TIME=[$6], A_TIMESTAMP=[$7], X_DECIMAL=[$8], X_LONG=[$9], X_INTEGER=[$10], Y_INTEGER=[$11], A_BYTE=[$12], A_SHORT=[$13], A_FLOAT=[$14], A_DOUBLE=[$15], A_UNSIGNED_FLOAT=[$16], A_UNSIGNED_DOUBLE=[$17])\n" +
-                   "      PhoenixTableScan(table=[[phoenix, IDX_FULL]], filter=[=($0, 'b')])\n")
+                       "  PhoenixServerProject(ORGANIZATION_ID=[$1], ENTITY_ID=[$2], A_STRING=[$3], B_STRING=[$0], A_INTEGER=[$4], A_DATE=[$5], A_TIME=[$6], A_TIMESTAMP=[$7], X_DECIMAL=[$8], X_LONG=[$9], X_INTEGER=[$10], Y_INTEGER=[$11], A_BYTE=[$12], A_SHORT=[$13], A_FLOAT=[$14], A_DOUBLE=[$15], A_UNSIGNED_FLOAT=[$16], A_UNSIGNED_DOUBLE=[$17])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX_FULL]], filter=[=($0, 'b')])\n")
             .close();
         start(true).sql("select x_integer from aTable")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(X_INTEGER=[$4])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, IDX1]])\n")
+                       "  PhoenixServerProject(X_INTEGER=[$4])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX1]])\n")
             .close();
         start(true).sql("select a_string from aTable order by a_string")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(A_STRING=[$0])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, IDX1]])\n")
+                       "  PhoenixServerProject(A_STRING=[$0])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX1]], scanOrder=[FORWARD])\n")
             .close();
         start(true).sql("select a_string from aTable order by organization_id")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(A_STRING=[$2], ORGANIZATION_ID=[$0])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, ATABLE]])\n")
+                       "  PhoenixServerProject(A_STRING=[$2], ORGANIZATION_ID=[$0])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, ATABLE]], scanOrder=[FORWARD])\n")
             .close();
         start(true).sql("select a_integer from aTable order by a_string")
             .explainIs("PhoenixToEnumerableConverter\n" +
@@ -1093,26 +1146,23 @@ public class CalciteIT extends BaseClientManagedTimeIT {
             .close();
         start(true).sql("select a_string, b_string from aTable where a_string = 'a'")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(A_STRING=[$0], B_STRING=[$3])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, IDX1]], filter=[=($0, 'a')])\n")
+                       "  PhoenixServerProject(A_STRING=[$0], B_STRING=[$3])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX1]], filter=[=($0, 'a')])\n")
             .close();
         start(true).sql("select a_string, b_string from aTable where b_string = 'b'")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(A_STRING=[$3], B_STRING=[$0])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, IDX2]], filter=[=($0, 'b')])\n")
+                       "  PhoenixServerProject(A_STRING=[$3], B_STRING=[$0])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX2]], filter=[=($0, 'b')])\n")
             .close();
         start(true).sql("select a_string, b_string, x_integer, y_integer from aTable where b_string = 'b'")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(A_STRING=[$3], B_STRING=[$0], X_INTEGER=[$10], Y_INTEGER=[$11])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, IDX_FULL]], filter=[=($0, 'b')])\n")
+                       "  PhoenixServerProject(A_STRING=[$3], B_STRING=[$0], X_INTEGER=[$10], Y_INTEGER=[$11])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, IDX_FULL]], filter=[=($0, 'b')])\n")
             .close();
         start(true).sql("select a_string, count(*) from aTable group by a_string")
             .explainIs("PhoenixToEnumerableConverter\n" +
                        "  PhoenixServerAggregate(group=[{0}], EXPR$1=[COUNT()], isOrdered=[true])\n" +
-                       "    PhoenixTableScan(table=[[phoenix, IDX1]])\n")
+                       "    PhoenixTableScan(table=[[phoenix, IDX1]], scanOrder=[FORWARD])\n")
             .close();
     }
     
@@ -1134,12 +1184,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("select entity_id from atable where a_string = 'a' union all select entity_id from atable where a_string = 'b'")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixUnion(all=[true])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerProject(ENTITY_ID=[$1])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerProject(ENTITY_ID=[$1])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'b')])\n")
+                           "    PhoenixServerProject(ENTITY_ID=[$1])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
+                           "    PhoenixServerProject(ENTITY_ID=[$1])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'b')])\n")
                 .resultIs(new Object[][] {
                         {"00A123122312312"},
                         {"00A223122312312"},
@@ -1191,9 +1239,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(false).sql("SELECT t.s FROM UNNEST((SELECT scores FROM " + SCORES_TABLE_NAME + ")) AS t(s)")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixUncollect\n" +
-                           "    PhoenixToClientConverter\n" +
-                           "      PhoenixServerProject(EXPR$0=[$2])\n" +
-                           "        PhoenixTableScan(table=[[phoenix, SCORES]])\n")
+                           "    PhoenixServerProject(EXPR$0=[$2])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, SCORES]])\n")
                 .resultIs(new Object[][] {
                         {85}, 
                         {80}, 
@@ -1206,12 +1253,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixClientProject(STUDENT_ID=[$0], SCORE=[$3])\n" +
                            "    PhoenixCorrelate(correlation=[$cor0], joinType=[INNER], requiredColumns=[{0}])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixTableScan(table=[[phoenix, SCORES]])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, SCORES]])\n" +
                            "      PhoenixUncollect\n" +
-                           "        PhoenixToClientConverter\n" +
-                           "          PhoenixServerProject(EXPR$0=[$2])\n" +
-                           "            PhoenixTableScan(table=[[phoenix, SCORES]], filter=[=($cor0.STUDENT_ID, $0)])\n")
+                           "        PhoenixServerProject(EXPR$0=[$2])\n" +
+                           "          PhoenixTableScan(table=[[phoenix, SCORES]], filter=[=($cor0.STUDENT_ID, $0)])\n")
                 .resultIs(new Object[][] {
                         {1, 85}, 
                         {1, 80}, 
@@ -1239,21 +1284,19 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 "  PhoenixClientProject(order_id=[$0], QUANTITY=[$4])\n" +
                 "    PhoenixFilter(condition=[=($4, $7)])\n" +
                 "      PhoenixCorrelate(correlation=[$cor0], joinType=[LEFT], requiredColumns=[{2}])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                "        PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
                 "        PhoenixServerAggregate(group=[{}], EXPR$0=[MAX($4)])\n" +
                 "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]], filter=[=($cor0.item_id, $2)])\n";
         String p1Decorrelated = 
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(order_id=[$0], QUANTITY=[$4])\n" +
-                "    PhoenixToClientConverter\n" +
-                "      PhoenixServerJoin(condition=[AND(=($2, $7), =($4, $8))], joinType=[inner])\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                "        PhoenixServerAggregate(group=[{7}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
-                "          PhoenixServerJoin(condition=[=($7, $2)], joinType=[inner])\n" +
-                "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                "            PhoenixServerAggregate(group=[{2}], isOrdered=[false])\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
+                "    PhoenixServerJoin(condition=[AND(=($2, $7), =($4, $8))], joinType=[inner])\n" +
+                "      PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                "      PhoenixServerAggregate(group=[{7}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
+                "        PhoenixServerJoin(condition=[=($7, $2)], joinType=[inner])\n" +
+                "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                "          PhoenixServerAggregate(group=[{2}], isOrdered=[false])\n" +
+                "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
         start(correlProps).sql(q1).explainIs(p1Correlate).resultIs(r1).close();
         start(decorrelProps).sql(q1).explainIs(p1Decorrelated).resultIs(r1).close();
                 
@@ -1270,79 +1313,50 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 "  PhoenixClientProject(NAME=[$1])\n" +
                 "    PhoenixFilter(condition=[=($2, $7)])\n" +
                 "      PhoenixCorrelate(correlation=[$cor0], joinType=[LEFT], requiredColumns=[{0, 1}])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
                 "        PhoenixServerAggregate(group=[{}], EXPR$0=[MAX($2)])\n" +
                 "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[AND(=($cor0.item_id, $0), =($cor0.NAME, $1), <>($0, 'invalid001'))])\n";
         String p2Decorrelated = 
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(NAME=[$1])\n" +
-                "    PhoenixToClientConverter\n" +
-                "      PhoenixServerJoin(condition=[AND(=($0, $7), =($1, $8), =($2, $9))], joinType=[inner])\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "        PhoenixServerAggregate(group=[{0, 1}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
-                "          PhoenixServerJoin(condition=[AND(=($0, $2), =($1, $3))], joinType=[inner])\n" +
-                "            PhoenixServerProject(item_id=[$0], NAME=[$1])\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "            PhoenixToClientConverter\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<>($0, 'invalid001')])\n";
+                "    PhoenixServerJoin(condition=[AND(=($0, $7), =($1, $8), =($2, $9))], joinType=[inner])\n" +
+                "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "      PhoenixServerAggregate(group=[{0, 1}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
+                "        PhoenixServerJoin(condition=[AND(=($0, $2), =($1, $3))], joinType=[inner])\n" +
+                "          PhoenixServerProject(item_id=[$0], NAME=[$1])\n" +
+                "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<>($0, 'invalid001')])\n";
         start(correlProps).sql(q2).explainIs(p2Correlate).resultIs(r2).close();
         start(decorrelProps).sql(q2).explainIs(p2Decorrelated).resultIs(r2).close();
         
-        String q3a = "select \"item_id\", name from " + JOIN_ITEM_TABLE_FULL_NAME + " i where exists (select 1 from " + JOIN_ORDER_TABLE_FULL_NAME + " o where i.\"item_id\" = o.\"item_id\")";
-        Object[][] r3a = new Object[][] {
+        // Test PhoenixClientSemiJoin
+        String q3 = "select \"item_id\", name from " + JOIN_ITEM_TABLE_FULL_NAME + " i where exists (select 1 from " + JOIN_ORDER_TABLE_FULL_NAME + " o where i.\"item_id\" = o.\"item_id\")";
+        Object[][] r3 = new Object[][] {
                 {"0000000001", "T1"},
                 {"0000000002", "T2"},
                 {"0000000003", "T3"},
                 {"0000000006", "T6"}};
-        String p3aCorrelate = 
+        String p3Correlate = 
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(item_id=[$0], NAME=[$1])\n" +
                 "    PhoenixFilter(condition=[IS NOT NULL($7)])\n" +
                 "      PhoenixCorrelate(correlation=[$cor0], joinType=[LEFT], requiredColumns=[{0}])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
                 "        PhoenixServerAggregate(group=[{}], agg#0=[MIN($0)])\n" +
                 "          PhoenixServerProject($f0=[true])\n" +
                 "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]], filter=[=($cor0.item_id, $2)])\n";
-        String p3aDecorrelated = 
+        String p3Decorrelated = 
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(item_id=[$0], NAME=[$1])\n" +
-                "    PhoenixToClientConverter\n" +
-                "      PhoenixServerSemiJoin(condition=[=($0, $7)], joinType=[inner])\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "        PhoenixClientProject(item_id0=[$0], $f0=[true])\n" +
-                "          PhoenixToClientConverter\n" +
-                "            PhoenixServerJoin(condition=[=($0, $3)], joinType=[inner])\n" +
-                "              PhoenixServerProject(item_id=[$0])\n" +
-                "                PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "              PhoenixToClientConverter\n" +
-                "                PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
-        start(correlProps).sql(q3a).explainIs(p3aCorrelate).resultIs(r3a).close();
-        start(decorrelProps).sql(q3a).explainIs(p3aDecorrelated).resultIs(r3a).close();
-        // Test PhoenixClientSemiJoin
-        String q3b = "select \"item_id\", name from " + JOIN_ITEM_TABLE_FULL_NAME + " i where exists (select 1 from " + JOIN_ITEM_TABLE_FULL_NAME + " o where i.\"item_id\" = o.\"item_id\" and name <> 'INVALID-1')";
-        Object[][] r3b = new Object[][] {
-                {"0000000001", "T1"},
-                {"0000000002", "T2"},
-                {"0000000003", "T3"},
-                {"0000000004", "T4"},
-                {"0000000005", "T5"},
-                {"0000000006", "T6"}};
-        String p3bDecorrelated =
-                "PhoenixToEnumerableConverter\n" +
-                "  PhoenixClientProject(item_id=[$0], NAME=[$1])\n" +
-                "    PhoenixClientSemiJoin(condition=[=($0, $8)], joinType=[inner])\n" +
-                "      PhoenixToClientConverter\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "      PhoenixClientProject($f0=[true], item_id0=[$0])\n" +
-                "        PhoenixClientJoin(condition=[=($0, $1)], joinType=[inner])\n" +
-                "          PhoenixToClientConverter\n" +
-                "            PhoenixServerProject(item_id=[$0])\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "          PhoenixToClientConverter\n" +
-                "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[<>(CAST($1):VARCHAR(9) CHARACTER SET \"ISO-8859-1\" COLLATE \"ISO-8859-1$en_US$primary\", 'INVALID-1')])\n";
-        start(decorrelProps).sql(q3b).explainIs(p3bDecorrelated).resultIs(r3b).close();
+                "    PhoenixClientSemiJoin(condition=[=($0, $7)], joinType=[inner])\n" +
+                "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]], scanOrder=[FORWARD])\n" +
+                "      PhoenixClientProject(item_id0=[$0], $f0=[true])\n" +
+                "        PhoenixServerJoin(condition=[=($0, $3)], joinType=[inner])\n" +
+                "          PhoenixServerProject(item_id=[$0])\n" +
+                "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]], scanOrder=[FORWARD])\n" +
+                "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
+        start(correlProps).sql(q3).explainIs(p3Correlate).resultIs(r3).close();
+        start(decorrelProps).sql(q3).explainIs(p3Decorrelated).resultIs(r3).close();
         
         String q4 = "select \"item_id\", name from " + JOIN_ITEM_TABLE_FULL_NAME + " i where \"item_id\" in (select \"item_id\" from " + JOIN_ORDER_TABLE_FULL_NAME + ")";
         Object[][] r4 = new Object[][] {
@@ -1352,12 +1366,10 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 {"0000000006", "T6"}};
         String p4Decorrelated = 
                 "PhoenixToEnumerableConverter\n" +
-                "  PhoenixToClientConverter\n" +
-                "    PhoenixServerSemiJoin(condition=[=($0, $4)], joinType=[inner])\n" +
-                "      PhoenixServerProject(item_id=[$0], NAME=[$1])\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "      PhoenixToClientConverter\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
+                "  PhoenixServerSemiJoin(condition=[=($0, $4)], joinType=[inner])\n" +
+                "    PhoenixServerProject(item_id=[$0], NAME=[$1])\n" +
+                "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "    PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
         start(decorrelProps).sql(q4).explainIs(p4Decorrelated).resultIs(r4).close();
         
         // CALCITE-864: switching orders and items in the first join wouldn't work.
@@ -1371,36 +1383,29 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 "  PhoenixClientProject(order_id=[$7])\n" +
                 "    PhoenixFilter(condition=[=($11, $14)])\n" +
                 "      PhoenixCorrelate(correlation=[$cor0], joinType=[LEFT], requiredColumns=[{5}])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixServerJoin(condition=[=($9, $0)], joinType=[inner])\n" +
-                "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "            PhoenixToClientConverter\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                "        PhoenixServerJoin(condition=[=($9, $0)], joinType=[inner])\n" +
+                "          PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
                 "        PhoenixServerAggregate(group=[{}], EXPR$0=[MAX($4)])\n" +
                 "          PhoenixServerJoin(condition=[=($2, $7)], joinType=[inner])\n" +
                 "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                "            PhoenixToClientConverter\n" +
-                "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[=($cor0.supplier_id, $5)])\n";
+                "            PhoenixTableScan(table=[[phoenix, Join, ItemTable]], filter=[=($cor0.supplier_id, $5)])\n";
         String p5Decorrelated =
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(order_id=[$7])\n" +
-                "    PhoenixToClientConverter\n" +
-                "      PhoenixServerJoin(condition=[AND(=($9, $0), =($5, $14))], joinType=[inner])\n" +
-                "        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixServerJoin(condition=[=($4, $8)], joinType=[inner])\n" +
+                "    PhoenixServerJoin(condition=[AND(=($5, $14), =($9, $0))], joinType=[inner])\n" +
+                "      PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "      PhoenixServerJoin(condition=[=($4, $8)], joinType=[inner])\n" +
+                "        PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
+                "        PhoenixServerAggregate(group=[{14}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
+                "          PhoenixServerJoin(condition=[=($2, $7)], joinType=[inner])\n" +
                 "            PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                "            PhoenixServerAggregate(group=[{14}], EXPR$0=[MAX($4)], isOrdered=[false])\n" +
-                "              PhoenixServerJoin(condition=[=($2, $7)], joinType=[inner])\n" +
-                "                PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n" +
-                "                PhoenixToClientConverter\n" +
-                "                  PhoenixServerJoin(condition=[=($7, $5)], joinType=[inner])\n" +
-                "                    PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "                    PhoenixServerAggregate(group=[{5}], isOrdered=[false])\n" +
-                "                      PhoenixServerJoin(condition=[=($9, $0)], joinType=[inner])\n" +
-                "                        PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
-                "                        PhoenixToClientConverter\n" +
-                "                          PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
+                "            PhoenixServerJoin(condition=[=($7, $5)], joinType=[inner])\n" +
+                "              PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "              PhoenixServerAggregate(group=[{5}], isOrdered=[false])\n" +
+                "                PhoenixServerJoin(condition=[=($9, $0)], joinType=[inner])\n" +
+                "                  PhoenixTableScan(table=[[phoenix, Join, ItemTable]])\n" +
+                "                  PhoenixTableScan(table=[[phoenix, Join, OrderTable]])\n";
         start(correlProps).sql(q5).explainIs(p5Correlate).resultIs(r5).close();
         start(decorrelProps).sql(q5).explainIs(p5Decorrelated).resultIs(r5).close();
         
@@ -1414,21 +1419,19 @@ public class CalciteIT extends BaseClientManagedTimeIT {
                 "  PhoenixClientProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_INTEGER=[$4])\n" +
                 "    PhoenixFilter(condition=[=($4, $18)])\n" +
                 "      PhoenixCorrelate(correlation=[$cor0], joinType=[LEFT], requiredColumns=[{0, 3}])\n" +
-                "        PhoenixToClientConverter\n" +
-                "          PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
+                "        PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
                 "        PhoenixServerAggregate(group=[{}], EXPR$0=[MIN($4)])\n" +
                 "          PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[AND(=($2, 'a'), =($cor0.ORGANIZATION_ID, $0), =($cor0.B_STRING, $3))])\n";
         String p6Decorrelated = 
                 "PhoenixToEnumerableConverter\n" +
                 "  PhoenixClientProject(ORGANIZATION_ID=[$0], ENTITY_ID=[$1], A_INTEGER=[$4])\n" +
-                "    PhoenixToClientConverter\n" +
-                "      PhoenixServerJoin(condition=[AND(=($0, $18), =($3, $19), =($4, $20))], joinType=[inner])\n" +
-                "        PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
-                "        PhoenixServerAggregate(group=[{18, 19}], EXPR$0=[MIN($4)], isOrdered=[false])\n" +
-                "          PhoenixServerJoin(condition=[AND(=($18, $0), =($19, $3))], joinType=[inner])\n" +
-                "            PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
-                "            PhoenixServerAggregate(group=[{0, 3}], isOrdered=[false])\n" +
-                "              PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n";
+                "    PhoenixServerJoin(condition=[AND(=($0, $18), =($3, $19), =($4, $20))], joinType=[inner])\n" +
+                "      PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
+                "      PhoenixServerAggregate(group=[{18, 19}], EXPR$0=[MIN($4)], isOrdered=[false])\n" +
+                "        PhoenixServerJoin(condition=[AND(=($18, $0), =($19, $3))], joinType=[inner])\n" +
+                "          PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n" +
+                "          PhoenixServerAggregate(group=[{0, 3}], isOrdered=[false])\n" +
+                "            PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n";
         start(correlProps).sql(q6).explainIs(p6Correlate).resultIs(r6).close();
         start(decorrelProps).sql(q6).explainIs(p6Decorrelated).resultIs(r6).close();
     }
@@ -1436,9 +1439,8 @@ public class CalciteIT extends BaseClientManagedTimeIT {
     @Test public void testInValueList() {
         start(false).sql("select entity_id from aTable where organization_id = '00D300000000XHP' and entity_id in ('00A123122312312', '00A223122312312', '00B523122312312', '00B623122312312', '00C923122312312')")
             .explainIs("PhoenixToEnumerableConverter\n" +
-                       "  PhoenixToClientConverter\n" +
-                       "    PhoenixServerProject(ENTITY_ID=[$1])\n" +
-                       "      PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[AND(=($0, '00D300000000XHP'), OR(=($1, '00A123122312312'), =($1, '00A223122312312'), =($1, '00B523122312312'), =($1, '00B623122312312'), =($1, '00C923122312312')))])\n")
+                       "  PhoenixServerProject(ENTITY_ID=[$1])\n" +
+                       "    PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[AND(=($0, '00D300000000XHP'), OR(=($1, '00A123122312312'), =($1, '00A223122312312'), =($1, '00B523122312312'), =($1, '00B623122312312'), =($1, '00C923122312312')))])\n")
             .resultIs(new Object[][] {
                     {"00A123122312312"},
                     {"00A223122312312"},
@@ -1451,8 +1453,7 @@ public class CalciteIT extends BaseClientManagedTimeIT {
     @Test public void testSelectFromView() {
         start(false).sql("select * from v")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
+                           "  PhoenixTableScan(table=[[phoenix, ATABLE]], filter=[=($2, 'a')])\n")
                 .resultIs(new Object[][] {
                         {"00D300000000XHP", "00A123122312312", "a"}, 
                         {"00D300000000XHP", "00A223122312312", "a"}, 
@@ -1465,23 +1466,20 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(true).sql("select count(*) from " + NOSALT_TABLE_NAME + " where col0 > 3")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{}], EXPR$0=[COUNT()])\n" +
-                           "    PhoenixServerProject(DUMMY=[0])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDXSALTED_NOSALT_TEST_TABLE:unordered]], filter=[>(CAST($0):INTEGER, 3)])\n")
+                           "    PhoenixTableScan(table=[[phoenix, IDXSALTED_NOSALT_TEST_TABLE]], filter=[>(CAST($0):INTEGER, 3)])\n")
                 .resultIs(new Object[][]{{2L}})
                 .close();
         start(true).sql("select mypk0, mypk1, col0 from " + NOSALT_TABLE_NAME + " where col0 <= 4")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[CAST($0):INTEGER])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDXSALTED_NOSALT_TEST_TABLE:unordered]], filter=[<=(CAST($0):INTEGER, 4)])\n")
+                           "  PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[CAST($0):INTEGER])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, IDXSALTED_NOSALT_TEST_TABLE]], filter=[<=(CAST($0):INTEGER, 4)])\n")
                 .resultIs(new Object[][] {
                         {2, 3, 4},
                         {1, 2, 3}})
                 .close();
         start(true).sql("select * from " + SALTED_TABLE_NAME + " where mypk0 < 3")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE:unordered]], filter=[<($0, 3)])\n")
+                           "  PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE]], filter=[<($0, 3)])\n")
                 .resultIs(new Object[][] {
                         {1, 2, 3, 4},
                         {2, 3, 4, 5}})
@@ -1489,15 +1487,13 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(true).sql("select count(*) from " + SALTED_TABLE_NAME + " where col0 > 3")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{}], EXPR$0=[COUNT()])\n" +
-                           "    PhoenixServerProject(DUMMY=[0])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDX_SALTED_TEST_TABLE:unordered]], filter=[>(CAST($0):INTEGER, 3)])\n")
+                           "    PhoenixTableScan(table=[[phoenix, IDX_SALTED_TEST_TABLE]], filter=[>(CAST($0):INTEGER, 3)])\n")
                 .resultIs(new Object[][]{{2L}})
                 .close();
         start(true).sql("select mypk0, mypk1, col0 from " + SALTED_TABLE_NAME + " where col0 <= 4")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[CAST($0):INTEGER])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDX_SALTED_TEST_TABLE:unordered]], filter=[<=(CAST($0):INTEGER, 4)])\n")
+                           "  PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[CAST($0):INTEGER])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, IDX_SALTED_TEST_TABLE]], filter=[<=(CAST($0):INTEGER, 4)])\n")
                 .resultIs(new Object[][] {
                         {2, 3, 4},
                         {1, 2, 3}})
@@ -1505,27 +1501,23 @@ public class CalciteIT extends BaseClientManagedTimeIT {
         start(true).sql("select count(*) from " + SALTED_TABLE_NAME + " where col1 > 4")
                 .explainIs("PhoenixToEnumerableConverter\n" +
                            "  PhoenixServerAggregate(group=[{}], EXPR$0=[COUNT()])\n" +
-                           "    PhoenixServerProject(DUMMY=[0])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE:unordered]], filter=[>(CAST($0):INTEGER, 4)])\n")
+                           "    PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE]], filter=[>(CAST($0):INTEGER, 4)])\n")
                 .resultIs(new Object[][]{{2L}})
                 .close();
         start(true).sql("select * from " + SALTED_TABLE_NAME + " where col1 <= 5 order by col1")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[$3], COL1=[CAST($0):INTEGER])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE]], filter=[<=(CAST($0):INTEGER, 5)])\n")
+                           "  PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[$3], COL1=[CAST($0):INTEGER])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE]], filter=[<=(CAST($0):INTEGER, 5)], scanOrder=[FORWARD])\n")
                 .resultIs(new Object[][] {
                         {1, 2, 3, 4},
                         {2, 3, 4, 5}})
                 .close();
         start(true).sql("select * from " + SALTED_TABLE_NAME + " s1, " + SALTED_TABLE_NAME + " s2 where s1.mypk0 = s2.mypk0 and s1.mypk1 = s2.mypk1 and s1.mypk0 > 1 and s2.col1 < 6")
                 .explainIs("PhoenixToEnumerableConverter\n" +
-                           "  PhoenixToClientConverter\n" +
-                           "    PhoenixServerJoin(condition=[AND(=($0, $4), =($1, $5))], joinType=[inner])\n" +
-                           "      PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE:unordered]], filter=[>($0, 1)])\n" +
-                           "      PhoenixToClientConverter\n" +
-                           "        PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[$3], COL1=[CAST($0):INTEGER])\n" +
-                           "          PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE:unordered]], filter=[<(CAST($0):INTEGER, 6)])\n")
+                           "  PhoenixServerJoin(condition=[AND(=($0, $4), =($1, $5))], joinType=[inner])\n" +
+                           "    PhoenixTableScan(table=[[phoenix, SALTED_TEST_TABLE]], filter=[>($0, 1)])\n" +
+                           "    PhoenixServerProject(MYPK0=[$1], MYPK1=[$2], COL0=[$3], COL1=[CAST($0):INTEGER])\n" +
+                           "      PhoenixTableScan(table=[[phoenix, IDXSALTED_SALTED_TEST_TABLE]], filter=[<(CAST($0):INTEGER, 6)])\n")
                 .resultIs(new Object[][] {
                         {2, 3, 4, 5, 2, 3, 4, 5}})
                 .close();
@@ -1554,8 +1546,7 @@ public class CalciteIT extends BaseClientManagedTimeIT {
             .explainIs("EnumerableCalc(expr#0..8=[{inputs}], THE_YEAR=[$t6], Q=[$t4], EXPR$2=[$t8])\n" +
                        "  EnumerableJoin(condition=[=($6, $7)], joinType=[left])\n" +
   

<TRUNCATED>

[2/4] phoenix git commit: PHOENIX-1844, PHOENIX-1879

Posted by ma...@apache.org.
http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/CalciteUtils.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/CalciteUtils.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/CalciteUtils.java
index e5c70c0..92c2641 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/CalciteUtils.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/CalciteUtils.java
@@ -7,6 +7,10 @@ import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.calcite.avatica.util.ByteString;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelFieldCollation.Direction;
 import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexCorrelVariable;
@@ -149,6 +153,28 @@ public class CalciteUtils {
         
         return ret;
     }
+    
+    public static RelCollation reverseCollation(RelCollation collation) {
+        if (collation.getFieldCollations().isEmpty())
+            return collation;
+        
+        List<RelFieldCollation> fieldCollations = Lists.newArrayList();
+        for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
+            Direction dir = null;
+            switch (fieldCollation.direction) {
+            case ASCENDING:
+                dir = Direction.DESCENDING;
+                break;
+            case DESCENDING:
+                dir = Direction.ASCENDING;
+                break;
+            default:
+                assert false : "Shouldn't have come accross non Phoenix directions";
+            }
+            fieldCollations.add(new RelFieldCollation(fieldCollation.getFieldIndex(), dir, fieldCollation.nullDirection));
+        }
+        return RelCollations.of(fieldCollations);
+    }
 
 	private static final Map<SqlKind, ExpressionFactory> EXPRESSION_MAP = Maps
 			.newHashMapWithExpectedSize(ExpressionType.values().length);

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixSchema.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixSchema.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixSchema.java
index a6c10b7..01913b9 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixSchema.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixSchema.java
@@ -20,7 +20,6 @@ import org.apache.phoenix.parse.TableName;
 import org.apache.phoenix.schema.MetaDataClient;
 import org.apache.phoenix.schema.PColumn;
 import org.apache.phoenix.schema.PTable;
-import org.apache.phoenix.schema.PTable.IndexType;
 import org.apache.phoenix.schema.PTable.ViewType;
 import org.apache.phoenix.schema.PTableType;
 import org.apache.phoenix.schema.TableRef;
@@ -49,11 +48,11 @@ import java.util.Set;
  */
 public class PhoenixSchema implements Schema {
     public static final Factory FACTORY = new Factory();
-    private static final String UNORDERED_SUFFIX = ":unordered";
+
+    public final PhoenixConnection pc;
     
     protected final String name;
     protected final String schemaName;
-    protected final PhoenixConnection pc;
     protected final MetaDataClient client;
     
     protected final Set<String> subSchemaNames;
@@ -105,12 +104,7 @@ public class PhoenixSchema implements Schema {
                                     ImmutableList.<ColumnDef>of()), pc);
                     final List<TableRef> tables = x.getTables();
                     assert tables.size() == 1;
-                    final PTable pTable = tables.get(0).getTable();
-                    tableMap.put(tableName, pTable);
-                    if (pTable.getBucketNum() != null || pTable.getIndexType() == IndexType.LOCAL) {
-                        final String unorderedTableName = tableName + UNORDERED_SUFFIX;
-                        tableMap.put(unorderedTableName, pTable);
-                    }
+                    tableMap.put(tableName, tables.get(0).getTable());
                 } else {
                     String viewSql = rs.getString(PhoenixDatabaseMetaData.VIEW_STATEMENT);
                     String viewType = rs.getString(PhoenixDatabaseMetaData.VIEW_TYPE);
@@ -145,7 +139,7 @@ public class PhoenixSchema implements Schema {
     @Override
     public Table getTable(String name) {
         PTable table = tableMap.get(name);
-        return table == null ? null : new PhoenixTable(pc, table, !isUnorderedTableName(name));
+        return table == null ? null : new PhoenixTable(pc, table);
     }
 
     @Override
@@ -204,20 +198,9 @@ public class PhoenixSchema implements Schema {
     
     public void defineIndexesAsMaterializations(CalciteSchema calciteSchema) {
         List<String> path = calciteSchema.path(null);
-        for (Map.Entry<String, PTable> entry : tableMap.entrySet()) {
-            final String tableName = entry.getKey();
-            final PTable table = entry.getValue();
-            if (!isUnorderedTableName(tableName)) {
-                for (PTable index : table.getIndexes()) {
-                    addMaterialization(table, index, path, calciteSchema);
-                }
-            }
-        }
-        for (Map.Entry<String, PTable> entry : tableMap.entrySet()) {
-            final String tableName = entry.getKey();
-            final PTable table = entry.getValue();
-            if (isUnorderedTableName(tableName)) {
-                addUnorderedAsMaterialization(tableName, table, path, calciteSchema);
+        for (PTable table : tableMap.values()) {
+            for (PTable index : table.getIndexes()) {
+                addMaterialization(table, index, path, calciteSchema);
             }
         }
     }
@@ -239,21 +222,6 @@ public class PhoenixSchema implements Schema {
                 calciteSchema, null, sb.toString(), path, index.getTableName().getString(), true, true);        
     }
     
-    protected void addUnorderedAsMaterialization(String tableName, PTable table, List<String> path,
-            CalciteSchema calciteSchema) {
-        StringBuffer sb = new StringBuffer();
-        sb.append("SELECT * FROM ")
-            .append("\"")
-            .append(table.getTableName().getString())
-            .append("\"");
-        MaterializationService.instance().defineMaterialization(
-                calciteSchema, null, sb.toString(), path, tableName, true, true);        
-    }
-    
-    private boolean isUnorderedTableName(String tableName) {
-        return tableName.endsWith(UNORDERED_SUFFIX);
-    }
-    
     private static class ViewDef {
         final String viewSql;
         final boolean updatable;

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixTable.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixTable.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixTable.java
index 272cd47..cb07a7c 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixTable.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/PhoenixTable.java
@@ -2,7 +2,6 @@ package org.apache.phoenix.calcite;
 
 import java.util.List;
 
-import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollationTraitDef;
@@ -19,7 +18,6 @@ import org.apache.calcite.schema.TranslatableTable;
 import org.apache.calcite.schema.impl.AbstractTable;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.phoenix.calcite.rel.PhoenixRel;
 import org.apache.phoenix.calcite.rel.PhoenixTableScan;
 import org.apache.phoenix.jdbc.PhoenixConnection;
 import org.apache.phoenix.schema.PColumn;
@@ -42,25 +40,21 @@ public class PhoenixTable extends AbstractTable implements TranslatableTable {
   public final ImmutableBitSet pkBitSet;
   public final RelCollation collation;
   public final PhoenixConnection pc;
-  public final boolean requireRowKeyOrder;
   
   public static int getStartingColumnPosition(PTable pTable) {
       return (pTable.getBucketNum() == null ? 0 : 1) + (pTable.isMultiTenant() ? 1 : 0) + (pTable.getViewIndexId() == null ? 0 : 1);
   }
 
-  public PhoenixTable(PhoenixConnection pc, PTable pTable, boolean requireRowKeyOrder) {
+  public PhoenixTable(PhoenixConnection pc, PTable pTable) {
       this.pc = Preconditions.checkNotNull(pc);
       this.pTable = Preconditions.checkNotNull(pTable);
-      this.requireRowKeyOrder = requireRowKeyOrder;
       List<Integer> pkPositions = Lists.<Integer> newArrayList();
       List<RelFieldCollation> fieldCollations = Lists.<RelFieldCollation> newArrayList();
-      if (requireRowKeyOrder) {
-          for (PColumn column : pTable.getPKColumns()) {
-              int position = column.getPosition();
-              SortOrder sortOrder = column.getSortOrder();
-              pkPositions.add(position);
-              fieldCollations.add(new RelFieldCollation(position, sortOrder == SortOrder.ASC ? Direction.ASCENDING : Direction.DESCENDING));
-          }
+      for (PColumn column : pTable.getPKColumns()) {
+          int position = column.getPosition();
+          SortOrder sortOrder = column.getSortOrder();
+          pkPositions.add(position);
+          fieldCollations.add(new RelFieldCollation(position, sortOrder == SortOrder.ASC ? Direction.ASCENDING : Direction.DESCENDING));
       }
       this.pkBitSet = ImmutableBitSet.of(pkPositions);
       this.collation = RelCollationTraitDef.INSTANCE.canonize(RelCollations.of(fieldCollations));
@@ -105,10 +99,7 @@ public class PhoenixTable extends AbstractTable implements TranslatableTable {
 
     @Override
     public RelNode toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
-        final RelOptCluster cluster = context.getCluster();
-        // TODO Is there a better place to do this?
-        cluster.setMetadataProvider(PhoenixRel.METADATA_PROVIDER);
-        return PhoenixTableScan.create(cluster, relOptTable, null);
+        return PhoenixTableScan.create(context.getCluster(), relOptTable);
     }
 
     @Override
@@ -132,9 +123,7 @@ public class PhoenixTable extends AbstractTable implements TranslatableTable {
 
             @Override
             public List<RelCollation> getCollations() {
-                return collation.getFieldCollations().isEmpty() ? 
-                        ImmutableList.<RelCollation>of()
-                      : ImmutableList.<RelCollation>of(collation);
+                return ImmutableList.<RelCollation>of(collation);
             }
 
             @Override

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/jdbc/PhoenixPrepareImpl.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/jdbc/PhoenixPrepareImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/jdbc/PhoenixPrepareImpl.java
index 677b966..a956eee 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/jdbc/PhoenixPrepareImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/jdbc/PhoenixPrepareImpl.java
@@ -5,6 +5,7 @@ import java.util.List;
 import org.apache.calcite.adapter.enumerable.EnumerableRules;
 import org.apache.calcite.jdbc.CalcitePrepare;
 import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptCostFactory;
 import org.apache.calcite.plan.RelOptPlanner;
 import org.apache.calcite.plan.RelOptRule;
@@ -12,8 +13,11 @@ import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.prepare.CalcitePrepareImpl;
 import org.apache.calcite.prepare.Prepare.Materialization;
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.logical.LogicalSort;
 import org.apache.calcite.rel.rules.JoinCommuteRule;
+import org.apache.calcite.rel.rules.SortProjectTransposeRule;
 import org.apache.calcite.rel.rules.SortUnionTransposeRule;
+import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.runtime.Hook;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParser;
@@ -22,15 +26,19 @@ import org.apache.calcite.tools.Programs;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.Pair;
 import org.apache.phoenix.calcite.PhoenixSchema;
-import org.apache.phoenix.calcite.metadata.PhoenixRelMetadataProvider;
 import org.apache.phoenix.calcite.parse.SqlCreateView;
 import org.apache.phoenix.calcite.parser.PhoenixParserImpl;
+import org.apache.phoenix.calcite.rel.PhoenixRel;
+import org.apache.phoenix.calcite.rel.PhoenixServerProject;
+import org.apache.phoenix.calcite.rel.PhoenixTemporarySort;
 import org.apache.phoenix.calcite.rules.PhoenixCompactClientSortRule;
 import org.apache.phoenix.calcite.rules.PhoenixFilterScanMergeRule;
-import org.apache.phoenix.calcite.rules.PhoenixInnerSortRemoveRule;
+import org.apache.phoenix.calcite.rules.PhoenixForwardTableScanRule;
 import org.apache.phoenix.calcite.rules.PhoenixJoinSingleValueAggregateMergeRule;
 import org.apache.phoenix.calcite.rules.PhoenixMergeSortUnionRule;
 import org.apache.phoenix.calcite.rules.PhoenixOrderedAggregateRule;
+import org.apache.phoenix.calcite.rules.PhoenixReverseTableScanRule;
+import org.apache.phoenix.calcite.rules.PhoenixSortServerJoinTransposeRule;
 
 import com.google.common.base.Function;
 
@@ -58,6 +66,14 @@ public class PhoenixPrepareImpl extends CalcitePrepareImpl {
     }
 
     @Override
+    protected RelOptCluster createCluster(RelOptPlanner planner,
+            RexBuilder rexBuilder) {
+        RelOptCluster cluster = super.createCluster(planner, rexBuilder);
+        cluster.setMetadataProvider(PhoenixRel.METADATA_PROVIDER);
+        return cluster;
+    }
+    
+    @Override
     protected RelOptPlanner createPlanner(
             final CalcitePrepare.Context prepareContext,
             org.apache.calcite.plan.Context externalContext,
@@ -69,16 +85,24 @@ public class PhoenixPrepareImpl extends CalcitePrepareImpl {
         planner.addRule(JoinCommuteRule.SWAP_OUTER);
         planner.removeRule(SortUnionTransposeRule.INSTANCE);
         planner.addRule(SortUnionTransposeRule.MATCH_NULL_FETCH);
+        planner.addRule(new SortProjectTransposeRule(
+                PhoenixTemporarySort.class,
+                PhoenixServerProject.class,
+                "PhoenixSortProjectTransposeRule"));
         
         for (RelOptRule rule : this.defaultConverterRules) {
             planner.addRule(rule);
         }
         planner.addRule(PhoenixFilterScanMergeRule.INSTANCE);
-        planner.addRule(PhoenixCompactClientSortRule.SORT_SERVERAGGREGATE);
+        planner.addRule(PhoenixCompactClientSortRule.INSTANCE);
         planner.addRule(PhoenixJoinSingleValueAggregateMergeRule.INSTANCE);
         planner.addRule(PhoenixMergeSortUnionRule.INSTANCE);
-        planner.addRule(PhoenixInnerSortRemoveRule.INSTANCE);
         planner.addRule(PhoenixOrderedAggregateRule.INSTANCE);
+        planner.addRule(PhoenixSortServerJoinTransposeRule.INSTANCE);
+        planner.addRule(new PhoenixForwardTableScanRule(LogicalSort.class));
+        planner.addRule(new PhoenixForwardTableScanRule(PhoenixTemporarySort.class));
+        planner.addRule(new PhoenixReverseTableScanRule(LogicalSort.class));
+        planner.addRule(new PhoenixReverseTableScanRule(PhoenixTemporarySort.class));
         
         for (CalciteSchema schema : prepareContext.getRootSchema().getSubSchemaMap().values()) {
             if (schema.schema instanceof PhoenixSchema) {
@@ -121,7 +145,7 @@ public class PhoenixPrepareImpl extends CalcitePrepareImpl {
 
 				// Second planner pass to do physical "tweaks". This the first time that
 				// EnumerableCalcRel is introduced.
-				final Program program2 = Programs.hep(Programs.CALC_RULES, true, new PhoenixRelMetadataProvider());;
+				final Program program2 = Programs.hep(Programs.CALC_RULES, true, PhoenixRel.METADATA_PROVIDER);;
 
 				Program p = Programs.sequence(program1, program2);
 				input.getValue().set(p);

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/metadata/PhoenixRelMdCollation.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/metadata/PhoenixRelMdCollation.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/metadata/PhoenixRelMdCollation.java
index 90606cd..d653627 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/metadata/PhoenixRelMdCollation.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/metadata/PhoenixRelMdCollation.java
@@ -1,6 +1,7 @@
 package org.apache.phoenix.calcite.metadata;
 
 import java.util.List;
+
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelNode;
@@ -17,6 +18,7 @@ import org.apache.phoenix.calcite.rel.PhoenixCorrelate;
 import org.apache.phoenix.calcite.rel.PhoenixLimit;
 import org.apache.phoenix.calcite.rel.PhoenixMergeSortUnion;
 import org.apache.phoenix.calcite.rel.PhoenixServerJoin;
+import org.apache.phoenix.calcite.rel.PhoenixTableScan;
 
 import com.google.common.collect.ImmutableList;
 
@@ -27,6 +29,10 @@ public class PhoenixRelMdCollation {
 
     private PhoenixRelMdCollation() { }
 
+    public ImmutableList<RelCollation> collations(PhoenixTableScan tableScan) {
+        return ImmutableList.copyOf(tableScan.getCollationList());
+    }
+
     public ImmutableList<RelCollation> collations(PhoenixCorrelate correlate) {
         return ImmutableList.copyOf(correlate(correlate.getLeft(), correlate.getRight(), correlate.getJoinType()));
     }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixAbstractAggregate.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixAbstractAggregate.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixAbstractAggregate.java
index 17a4cea..681414b 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixAbstractAggregate.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixAbstractAggregate.java
@@ -1,6 +1,7 @@
 package org.apache.phoenix.calcite.rel;
 
 import java.util.List;
+import java.util.Set;
 
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptCost;
@@ -15,10 +16,9 @@ import org.apache.calcite.rel.core.Aggregate;
 import org.apache.calcite.rel.core.AggregateCall;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.ImmutableIntList;
-import org.apache.calcite.util.Util;
 import org.apache.phoenix.calcite.CalciteUtils;
-import org.apache.phoenix.compile.QueryPlan;
 import org.apache.phoenix.compile.GroupByCompiler.GroupBy;
+import org.apache.phoenix.compile.QueryPlan;
 import org.apache.phoenix.compile.StatementContext;
 import org.apache.phoenix.coprocessor.BaseScannerRegionObserver;
 import org.apache.phoenix.execute.TupleProjectionPlan;
@@ -34,6 +34,7 @@ import org.apache.phoenix.schema.RowKeyValueAccessor;
 import org.apache.phoenix.schema.TableRef;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 
 /**
  * Implementation of {@link org.apache.calcite.rel.core.Aggregate}
@@ -50,22 +51,30 @@ abstract public class PhoenixAbstractAggregate extends Aggregate implements Phoe
         return call.getAggregation().getName().equals("SINGLE_VALUE");
     }
     
-    public static boolean isOrderedGroupSet(ImmutableBitSet groupSet, RelNode child) {
-        List<Integer> ordinals = groupSet.asList();
+    protected static boolean isOrderedGroupSet(ImmutableBitSet groupSet, RelNode child) {
+        if (groupSet.isEmpty()) {
+            return true;
+        }
+        
+        Set<Integer> ordinals = Sets.newHashSet(groupSet.asList());
         List<RelCollation> collations = child.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
-        boolean isOrderedGroupBy = ordinals.isEmpty();
-        for (int i = 0; i < collations.size() && !isOrderedGroupBy; i++) {
+        for (int i = 0; i < collations.size(); i++) {
+            int count = 0;
             List<RelFieldCollation> fieldCollations = collations.get(i).getFieldCollations();
-            List<Integer> fields = Lists.newArrayListWithExpectedSize(fieldCollations.size());
-            for (RelFieldCollation fieldCollation : fieldCollations) {
-                fields.add(fieldCollation.getFieldIndex());
+            if (fieldCollations.size() < ordinals.size()) {
+                continue;
+            }
+            for (RelFieldCollation fieldCollation : fieldCollations.subList(0, ordinals.size())) {
+                if (ordinals.contains(fieldCollation.getFieldIndex())) {
+                    count++;
+                }
             }
-            if (Util.startsWith(fields, ordinals)) {
-                isOrderedGroupBy = true;
+            if (count == ordinals.size()) {
+                return true;
             }
         }
         
-        return isOrderedGroupBy;
+        return false;
     }
     
     public final boolean isOrderedGroupBy;
@@ -93,7 +102,7 @@ abstract public class PhoenixAbstractAggregate extends Aggregate implements Phoe
         if (isSingleValueCheckAggregate(this))
             return planner.getCostFactory().makeInfiniteCost();
         
-        double orderedGroupByFactor = isOrderedGroupBy ? 0.8 : 1.0;
+        double orderedGroupByFactor = isOrderedGroupBy ? 0.5 : 1.0;
         return super.computeSelfCost(planner).multiplyBy(orderedGroupByFactor);
     }
 

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientAggregate.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientAggregate.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientAggregate.java
index c62c328..49b8cdf 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientAggregate.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientAggregate.java
@@ -29,7 +29,7 @@ public class PhoenixClientAggregate extends PhoenixAbstractAggregate {
             ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, 
             List<AggregateCall> aggCalls) {
         RelOptCluster cluster = input.getCluster();
-        RelTraitSet traits = cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION);
+        RelTraitSet traits = cluster.traitSetOf(PhoenixConvention.CLIENT);
         return new PhoenixClientAggregate(cluster, traits, input, indicator, 
                 groupSet, groupSets, aggCalls);
     }
@@ -49,7 +49,7 @@ public class PhoenixClientAggregate extends PhoenixAbstractAggregate {
     
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.CLIENT))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientJoin.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientJoin.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientJoin.java
index 9eba164..d51e9e8 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientJoin.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientJoin.java
@@ -46,7 +46,7 @@ public class PhoenixClientJoin extends PhoenixAbstractJoin {
         RelOptCluster cluster = left.getCluster();
         final JoinInfo joinInfo = JoinInfo.of(left, right, condition);
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -77,8 +77,8 @@ public class PhoenixClientJoin extends PhoenixAbstractJoin {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getLeft().getConvention() != PhoenixRel.CLIENT_CONVENTION 
-                || getRight().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getLeft().getConvention().satisfies(PhoenixConvention.GENERIC) 
+                || !getRight().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();            
         
         if (joinType == JoinRelType.RIGHT

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientProject.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientProject.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientProject.java
index e170553..94552ab 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientProject.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientProject.java
@@ -24,7 +24,7 @@ public class PhoenixClientProject extends PhoenixAbstractProject {
             final List<? extends RexNode> projects, RelDataType rowType) {
         RelOptCluster cluster = input.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -47,7 +47,8 @@ public class PhoenixClientProject extends PhoenixAbstractProject {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.SERVERJOIN)
+                && !getInput().getConvention().satisfies(PhoenixConvention.CLIENT))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSemiJoin.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSemiJoin.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSemiJoin.java
index 0611a8c..401a3b7 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSemiJoin.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSemiJoin.java
@@ -38,7 +38,7 @@ public class PhoenixClientSemiJoin extends PhoenixAbstractSemiJoin implements
         RelOptCluster cluster = left.getCluster();
         final JoinInfo joinInfo = JoinInfo.of(left, right, condition);
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -64,8 +64,8 @@ public class PhoenixClientSemiJoin extends PhoenixAbstractSemiJoin implements
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getLeft().getConvention() != PhoenixRel.CLIENT_CONVENTION 
-                || getRight().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getLeft().getConvention().satisfies(PhoenixConvention.GENERIC) 
+                || !getRight().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();            
         
         if ((!leftKeys.isEmpty() && !RelCollations.contains(RelMetadataQuery.collations(getLeft()), leftKeys))

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSort.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSort.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSort.java
index f5a65df..bbc2005 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSort.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixClientSort.java
@@ -27,7 +27,7 @@ public class PhoenixClientSort extends PhoenixAbstractSort {
         RelOptCluster cluster = input.getCluster();
         collation = RelCollationTraitDef.INSTANCE.canonize(collation);
         RelTraitSet traits =
-            input.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION).replace(collation);
+            input.getTraitSet().replace(PhoenixConvention.CLIENT).replace(collation);
         return new PhoenixClientSort(cluster, traits, input, collation);
     }
 
@@ -44,7 +44,7 @@ public class PhoenixClientSort extends PhoenixAbstractSort {
     
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.CLIENT))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCompactClientSort.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCompactClientSort.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCompactClientSort.java
index 15372bd..8105f88 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCompactClientSort.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCompactClientSort.java
@@ -21,7 +21,7 @@ public class PhoenixCompactClientSort extends PhoenixAbstractSort {
         RelOptCluster cluster = input.getCluster();
         collation = RelCollationTraitDef.INSTANCE.canonize(collation);
         RelTraitSet traits =
-            input.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION).replace(collation);
+            input.getTraitSet().replace(PhoenixConvention.CLIENT).replace(collation);
         return new PhoenixCompactClientSort(cluster, traits, input, collation);
     }
 
@@ -38,7 +38,7 @@ public class PhoenixCompactClientSort extends PhoenixAbstractSort {
     
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.CLIENT))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixConvention.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixConvention.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixConvention.java
new file mode 100644
index 0000000..5006f43
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixConvention.java
@@ -0,0 +1,47 @@
+package org.apache.phoenix.calcite.rel;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.ConventionTraitDef;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTrait;
+import org.apache.calcite.plan.RelTraitDef;
+
+public enum PhoenixConvention implements Convention {
+    
+    /** Generic convention*/
+    GENERIC,
+    
+    /** Server convention*/
+    SERVER,
+    
+    /** Server join convention*/
+    SERVERJOIN,
+    
+    /** Client convention*/
+    CLIENT;
+
+    @Override
+    public RelTraitDef<?> getTraitDef() {
+        return ConventionTraitDef.INSTANCE;
+    }
+
+    @Override
+    public boolean satisfies(RelTrait trait) {
+        return this == trait || trait == GENERIC;
+    }
+
+    @Override
+    public void register(RelOptPlanner planner) {
+    }
+
+    @Override
+    public Class<PhoenixRel> getInterface() {
+        return PhoenixRel.class;
+    }
+
+    @Override
+    public String getName() {
+        return "PHOENIX_" + this.name();
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCorrelate.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCorrelate.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCorrelate.java
index 6518700..ae868d3 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCorrelate.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixCorrelate.java
@@ -33,7 +33,7 @@ public class PhoenixCorrelate extends Correlate implements PhoenixRel {
             final SemiJoinType joinType) {
         RelOptCluster cluster = left.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -60,9 +60,9 @@ public class PhoenixCorrelate extends Correlate implements PhoenixRel {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getLeft().getConvention() != PhoenixRel.CLIENT_CONVENTION 
-                || getRight().getConvention() != PhoenixRel.CLIENT_CONVENTION)
-            return planner.getCostFactory().makeInfiniteCost();   
+        if (!getLeft().getConvention().satisfies(PhoenixConvention.GENERIC)
+                || !getRight().getConvention().satisfies(PhoenixConvention.GENERIC))
+            return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner).multiplyBy(PHOENIX_FACTOR);
     }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixFilter.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixFilter.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixFilter.java
index a070d35..796ea00 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixFilter.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixFilter.java
@@ -29,7 +29,7 @@ public class PhoenixFilter extends Filter implements PhoenixRel {
     public static PhoenixFilter create(final RelNode input, final RexNode condition) {
         RelOptCluster cluster = input.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -49,7 +49,7 @@ public class PhoenixFilter extends Filter implements PhoenixRel {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner).multiplyBy(PHOENIX_FACTOR);

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixLimit.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixLimit.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixLimit.java
index fc7637e..4497919 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixLimit.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixLimit.java
@@ -29,7 +29,7 @@ public class PhoenixLimit extends SingleRel implements PhoenixRel {
     public static PhoenixLimit create(final RelNode input, RexNode offset, RexNode fetch) {
         RelOptCluster cluster = input.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -64,7 +64,7 @@ public class PhoenixLimit extends SingleRel implements PhoenixRel {
 
     @Override 
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();
         
         double rowCount = RelMetadataQuery.getRowCount(this);

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixMergeSortUnion.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixMergeSortUnion.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixMergeSortUnion.java
index 05b90ad..e23c03e 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixMergeSortUnion.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixMergeSortUnion.java
@@ -30,7 +30,7 @@ public class PhoenixMergeSortUnion extends Union implements PhoenixRel {
             final boolean all, final RelCollation collation) {
         RelOptCluster cluster = inputs.get(0).getCluster();
         RelTraitSet traits = 
-        		cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION)
+        		cluster.traitSetOf(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -53,7 +53,7 @@ public class PhoenixMergeSortUnion extends Union implements PhoenixRel {
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
         for (RelNode input : getInputs()) {
-            if (input.getConvention() != PhoenixRel.CLIENT_CONVENTION
+            if (!input.getConvention().satisfies(PhoenixConvention.GENERIC)
                     || !RelMetadataQuery.collations(input).contains(collation)) {
                 return planner.getCostFactory().makeInfiniteCost();
             }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixRel.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixRel.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixRel.java
index 7d269a8..f5e04be 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixRel.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixRel.java
@@ -2,7 +2,6 @@ package org.apache.phoenix.calcite.rel;
 
 import java.util.List;
 
-import org.apache.calcite.plan.Convention;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.metadata.RelMetadataProvider;
 import org.apache.calcite.util.ImmutableIntList;
@@ -24,11 +23,7 @@ import org.apache.phoenix.schema.types.PDataType;
  * over streams of {@link org.apache.phoenix.schema.tuple.Tuple}s.</p>
  */
 public interface PhoenixRel extends RelNode {
-  /** Calling conventions for relational operations that occur in Phoenix. */
-  Convention SERVER_CONVENTION = new Convention.Impl("PHOENIX_SERVER", PhoenixRel.class);
-  Convention SERVERJOIN_CONVENTION = new Convention.Impl("PHOENIX_SERVERJOIN", PhoenixRel.class);
-  Convention CLIENT_CONVENTION = new Convention.Impl("PHOENIX_CLIENT", PhoenixRel.class);
-  
+
   /** Metadata Provider for PhoenixRel */
   RelMetadataProvider METADATA_PROVIDER = new PhoenixRelMetadataProvider();
 

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerAggregate.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerAggregate.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerAggregate.java
index d208bef..2eb0d35 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerAggregate.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerAggregate.java
@@ -25,7 +25,7 @@ public class PhoenixServerAggregate extends PhoenixAbstractAggregate {
             ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, 
             List<AggregateCall> aggCalls) {
         RelOptCluster cluster = input.getCluster();
-        RelTraitSet traits = cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION);
+        RelTraitSet traits = cluster.traitSetOf(PhoenixConvention.CLIENT);
         return new PhoenixServerAggregate(cluster, traits, input, indicator, 
                 groupSet, groupSets, aggCalls);
     }
@@ -43,8 +43,8 @@ public class PhoenixServerAggregate extends PhoenixAbstractAggregate {
     
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.SERVER_CONVENTION
-                && getInput().getConvention() != PhoenixRel.SERVERJOIN_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.SERVER)
+                && !getInput().getConvention().satisfies(PhoenixConvention.SERVERJOIN))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerJoin.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerJoin.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerJoin.java
index 5419374..dcebb5d 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerJoin.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerJoin.java
@@ -40,7 +40,7 @@ public class PhoenixServerJoin extends PhoenixAbstractJoin {
             Set<String> variablesStopped, boolean isSingleValueRhs) {
         RelOptCluster cluster = left.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.SERVERJOIN_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.SERVERJOIN)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -72,8 +72,8 @@ public class PhoenixServerJoin extends PhoenixAbstractJoin {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getLeft().getConvention() != PhoenixRel.SERVER_CONVENTION 
-                || getRight().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getLeft().getConvention().satisfies(PhoenixConvention.SERVER)
+                || !getRight().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();            
         
         if (joinType == JoinRelType.FULL || joinType == JoinRelType.RIGHT)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerProject.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerProject.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerProject.java
index daa48f7..fbda9c6 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerProject.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerProject.java
@@ -24,7 +24,7 @@ public class PhoenixServerProject extends PhoenixAbstractProject {
             final List<? extends RexNode> projects, RelDataType rowType) {
         RelOptCluster cluster = input.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.SERVER_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.SERVER)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -47,7 +47,7 @@ public class PhoenixServerProject extends PhoenixAbstractProject {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.SERVER_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.SERVER))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSemiJoin.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSemiJoin.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSemiJoin.java
index b9a3576..928033b 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSemiJoin.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSemiJoin.java
@@ -36,7 +36,7 @@ public class PhoenixServerSemiJoin extends PhoenixAbstractSemiJoin {
             final RelNode left, final RelNode right, RexNode condition) {
         RelOptCluster cluster = left.getCluster();
         final RelTraitSet traits =
-                cluster.traitSet().replace(PhoenixRel.SERVERJOIN_CONVENTION)
+                cluster.traitSet().replace(PhoenixConvention.SERVERJOIN)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
@@ -64,8 +64,8 @@ public class PhoenixServerSemiJoin extends PhoenixAbstractSemiJoin {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getLeft().getConvention() != PhoenixRel.SERVER_CONVENTION 
-                || getRight().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getLeft().getConvention().satisfies(PhoenixConvention.SERVER) 
+                || !getRight().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();            
         
         //TODO return infinite cost if RHS size exceeds memory limit.

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSort.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSort.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSort.java
index b43754c..783ac87 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSort.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixServerSort.java
@@ -21,7 +21,7 @@ public class PhoenixServerSort extends PhoenixAbstractSort {
         RelOptCluster cluster = input.getCluster();
         collation = RelCollationTraitDef.INSTANCE.canonize(collation);
         RelTraitSet traits =
-            input.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION).replace(collation);
+            input.getTraitSet().replace(PhoenixConvention.CLIENT).replace(collation);
         return new PhoenixServerSort(cluster, traits, input, collation);
     }
 
@@ -38,8 +38,8 @@ public class PhoenixServerSort extends PhoenixAbstractSort {
     
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.SERVER_CONVENTION
-                && getInput().getConvention() != PhoenixRel.SERVERJOIN_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.SERVER)
+                && !getInput().getConvention().satisfies(PhoenixConvention.SERVERJOIN))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner)

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTableScan.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTableScan.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTableScan.java
index 567ddc0..1933ccb 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTableScan.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTableScan.java
@@ -39,6 +39,8 @@ import org.apache.phoenix.expression.LiteralExpression;
 import org.apache.phoenix.iterate.ParallelIteratorFactory;
 import org.apache.phoenix.jdbc.PhoenixStatement;
 import org.apache.phoenix.parse.SelectStatement;
+import org.apache.phoenix.query.QueryServices;
+import org.apache.phoenix.query.QueryServicesOptions;
 import org.apache.phoenix.schema.ColumnRef;
 import org.apache.phoenix.schema.KeyValueSchema.KeyValueSchemaBuilder;
 import org.apache.phoenix.schema.PColumn;
@@ -46,36 +48,53 @@ import org.apache.phoenix.schema.PName;
 import org.apache.phoenix.schema.PTable;
 import org.apache.phoenix.schema.TableRef;
 import org.apache.phoenix.schema.types.PDataType;
-import org.apache.phoenix.util.ScanUtil;
 import org.apache.phoenix.util.SchemaUtil;
 
 import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.Lists;
 
 /**
  * Scan of a Phoenix table.
  */
 public class PhoenixTableScan extends TableScan implements PhoenixRel {
+    public enum ScanOrder {
+        NONE,
+        FORWARD,
+        REVERSE,
+    }
+    
     public final RexNode filter;
+    public final ScanOrder scanOrder;
+    public final ScanRanges scanRanges;
     
-    private final ScanRanges scanRanges;
-        
+    public static PhoenixTableScan create(RelOptCluster cluster, final RelOptTable table) {
+        return create(cluster, table, null,
+                getDefaultScanOrder(table.unwrap(PhoenixTable.class)));
+    }
+
     public static PhoenixTableScan create(RelOptCluster cluster, final RelOptTable table, 
-            RexNode filter) {
+            RexNode filter, final ScanOrder scanOrder) {
         final RelTraitSet traits =
-                cluster.traitSetOf(PhoenixRel.SERVER_CONVENTION)
+                cluster.traitSetOf(PhoenixConvention.SERVER)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {
-                        return table.unwrap(PhoenixTable.class).getStatistic().getCollations();
+                        if (scanOrder == ScanOrder.NONE) {
+                            return ImmutableList.of();
+                        }
+                        List<RelCollation> collations = table.getCollationList();
+                        return scanOrder == ScanOrder.FORWARD ? collations : reverse(collations);
                     }
                 });
-        return new PhoenixTableScan(cluster, traits, table, filter);
+        return new PhoenixTableScan(cluster, traits, table, filter, scanOrder);
     }
 
-    private PhoenixTableScan(RelOptCluster cluster, RelTraitSet traits, RelOptTable table, RexNode filter) {
+    private PhoenixTableScan(RelOptCluster cluster, RelTraitSet traits, RelOptTable table, RexNode filter, ScanOrder scanOrder) {
         super(cluster, traits, table);
         this.filter = filter;
+        this.scanOrder = scanOrder;
         
         ScanRanges scanRanges = null;
         if (filter != null) {
@@ -116,6 +135,30 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
         }        
         this.scanRanges = scanRanges;
     }
+    
+    private static ScanOrder getDefaultScanOrder(PhoenixTable table) {
+        //TODO why attribute value not correct in connectUsingModel??
+        //return table.pc.getQueryServices().getProps().getBoolean(
+        //        QueryServices.FORCE_ROW_KEY_ORDER_ATTRIB,
+        //        QueryServicesOptions.DEFAULT_FORCE_ROW_KEY_ORDER) ?
+        //                ScanOrder.FORWARD : ScanOrder.NONE;
+        return ScanOrder.NONE;
+    }
+    
+    private static List<RelCollation> reverse(List<RelCollation> collations) {
+        Builder<RelCollation> builder = ImmutableList.<RelCollation>builder();
+        for (RelCollation collation : collations) {
+            builder.add(CalciteUtils.reverseCollation(collation));
+        }
+        return builder.build();
+    }
+    
+    public boolean isReverseScanEnabled() {
+        return table.unwrap(PhoenixTable.class).pc
+                .getQueryServices().getProps().getBoolean(
+                        QueryServices.USE_REVERSE_SCAN_ATTRIB,
+                        QueryServicesOptions.DEFAULT_USE_REVERSE_SCAN);
+    }
 
     @Override
     public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) {
@@ -126,7 +169,8 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
     @Override
     public RelWriter explainTerms(RelWriter pw) {
         return super.explainTerms(pw)
-            .itemIf("filter", filter, filter != null);
+            .itemIf("filter", filter, filter != null)
+            .itemIf("scanOrder", scanOrder, scanOrder != ScanOrder.NONE);
     }
 
     @Override
@@ -146,7 +190,7 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
         } else if (table.unwrap(PhoenixTable.class).getTable().getParentName() != null){
             rowCount = addEpsilon(rowCount);
         }
-        if (requireRowKeyOrder()) {
+        if (scanOrder != ScanOrder.NONE) {
             // We don't want to make a big difference here. The idea is to avoid
             // forcing row key order whenever the order is absolutely useless.
             // E.g. in "select count(*) from t" we do not need the row key order;
@@ -158,6 +202,9 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
             // eventually be an AggregatePlan, in which the "forceRowKeyOrder"
             // flag takes no effect.
             rowCount = addEpsilon(rowCount);
+            if (scanOrder == ScanOrder.REVERSE) {
+                rowCount = addEpsilon(rowCount);
+            }
         }
         int fieldCount = this.table.getRowType().getFieldCount();
         return planner.getCostFactory()
@@ -174,6 +221,11 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
         
         return rows;
     }
+    
+    @Override
+    public List<RelCollation> getCollationList() {
+        return getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);        
+    }
 
     @Override
     public QueryPlan implement(Implementor implementor) {
@@ -210,11 +262,12 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
                 implementor.setTableRef(new TableRef(projectedTable));
             }
             Integer limit = null;
-            OrderBy orderBy = OrderBy.EMPTY_ORDER_BY;
+            OrderBy orderBy = scanOrder == ScanOrder.NONE ?
+                      OrderBy.EMPTY_ORDER_BY
+                    : (scanOrder == ScanOrder.FORWARD ?
+                              OrderBy.FWD_ROW_KEY_ORDER_BY
+                            : OrderBy.REV_ROW_KEY_ORDER_BY);
             ParallelIteratorFactory iteratorFactory = null;
-            if (requireRowKeyOrder()) {
-                ScanUtil.setForceRowKeyOrder(context.getScan());
-            }
             return new ScanPlan(context, select, tableRef, RowProjector.EMPTY_PROJECTOR, limit, orderBy, iteratorFactory, true, dynamicFilter);
         } catch (SQLException e) {
             throw new RuntimeException(e);
@@ -247,10 +300,6 @@ public class PhoenixTableScan extends TableScan implements PhoenixRel {
             }
         }
     }
-    
-    private boolean requireRowKeyOrder() {
-        return table.unwrap(PhoenixTable.class).requireRowKeyOrder;
-    }
 
     private double addEpsilon(double d) {
       assert d >= 0d;

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTemporarySort.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTemporarySort.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTemporarySort.java
new file mode 100644
index 0000000..5ab289a
--- /dev/null
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixTemporarySort.java
@@ -0,0 +1,43 @@
+package org.apache.phoenix.calcite.rel;
+
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollationTraitDef;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rex.RexNode;
+import org.apache.phoenix.compile.QueryPlan;
+
+public class PhoenixTemporarySort extends PhoenixAbstractSort {
+
+    public static PhoenixTemporarySort create(RelNode input, RelCollation collation) {
+        RelOptCluster cluster = input.getCluster();
+        collation = RelCollationTraitDef.INSTANCE.canonize(collation);
+        RelTraitSet traits =
+                input.getTraitSet().replace(PhoenixConvention.SERVER).replace(collation);
+        return new PhoenixTemporarySort(cluster, traits, input, collation);
+    }
+
+    private PhoenixTemporarySort(RelOptCluster cluster, RelTraitSet traits,
+            RelNode child, RelCollation collation) {
+        super(cluster, traits, child, collation);
+    }
+
+    @Override
+    public PhoenixTemporarySort copy(RelTraitSet traitSet, RelNode newInput,
+            RelCollation newCollation, RexNode offset, RexNode fetch) {
+        return create(newInput, newCollation);
+    }
+
+    @Override
+    public RelOptCost computeSelfCost(RelOptPlanner planner) {
+        return planner.getCostFactory().makeInfiniteCost();
+    }
+
+    @Override
+    public QueryPlan implement(Implementor implementor) {
+        throw new UnsupportedOperationException();
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixToClientConverter.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixToClientConverter.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixToClientConverter.java
deleted file mode 100644
index f395787..0000000
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixToClientConverter.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package org.apache.phoenix.calcite.rel;
-
-import java.util.List;
-
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptCost;
-import org.apache.calcite.plan.RelOptPlanner;
-import org.apache.calcite.plan.RelTraitSet;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.SingleRel;
-import org.apache.phoenix.compile.QueryPlan;
-
-public class PhoenixToClientConverter extends SingleRel implements
-        PhoenixRel {
-    
-    public static PhoenixToClientConverter create(RelNode input) {
-        return new PhoenixToClientConverter(
-                input.getCluster(), 
-                input.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION), 
-                input);
-    }
-
-    private PhoenixToClientConverter(RelOptCluster cluster,
-            RelTraitSet traits, RelNode input) {
-        super(cluster, traits, input);
-    }
-    
-    @Override
-    public PhoenixToClientConverter copy(
-            RelTraitSet traitSet,
-            List<RelNode> newInputs) {
-        return create(sole(newInputs));
-    }
-
-    @Override 
-    public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        return planner.getCostFactory().makeCost(0, 0, 0);
-    }
-    
-    @Override
-    public QueryPlan implement(Implementor implementor) {
-        return implementor.visitInput(0, (PhoenixRel) getInput());
-    }
-
-}

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUncollect.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUncollect.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUncollect.java
index d39f3a6..71b7932 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUncollect.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUncollect.java
@@ -21,7 +21,7 @@ public class PhoenixUncollect extends Uncollect implements PhoenixRel {
     
     public static PhoenixUncollect create(RelNode input) {
         RelOptCluster cluster = input.getCluster();
-        RelTraitSet traits = cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION);
+        RelTraitSet traits = cluster.traitSetOf(PhoenixConvention.CLIENT);
         return new PhoenixUncollect(cluster, traits, input);
     }
 
@@ -38,7 +38,7 @@ public class PhoenixUncollect extends Uncollect implements PhoenixRel {
 
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
-        if (getInput().getConvention() != PhoenixRel.CLIENT_CONVENTION)
+        if (!getInput().getConvention().satisfies(PhoenixConvention.GENERIC))
             return planner.getCostFactory().makeInfiniteCost();
         
         return super.computeSelfCost(planner).multiplyBy(PHOENIX_FACTOR);

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUnion.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUnion.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUnion.java
index 8b0b616..8b9efb8 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUnion.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixUnion.java
@@ -25,7 +25,7 @@ public class PhoenixUnion extends Union implements PhoenixRel {
     
     public static PhoenixUnion create(List<RelNode> inputs, boolean all) {
         RelOptCluster cluster = inputs.get(0).getCluster();
-        RelTraitSet traits = cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION);
+        RelTraitSet traits = cluster.traitSetOf(PhoenixConvention.CLIENT);
         return new PhoenixUnion(cluster, traits, inputs, all);
     }
     
@@ -41,7 +41,7 @@ public class PhoenixUnion extends Union implements PhoenixRel {
     @Override
     public RelOptCost computeSelfCost(RelOptPlanner planner) {
         for (RelNode input : getInputs()) {
-            if (input.getConvention() != PhoenixRel.CLIENT_CONVENTION) {
+            if (!input.getConvention().satisfies(PhoenixConvention.GENERIC)) {
                 return planner.getCostFactory().makeInfiniteCost();
             }
         }

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixValues.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixValues.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixValues.java
index 22284e6..e53be9b 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixValues.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rel/PhoenixValues.java
@@ -72,7 +72,7 @@ public class PhoenixValues extends Values implements PhoenixRel {
     
     public static PhoenixValues create(RelOptCluster cluster, final RelDataType rowType, final ImmutableList<ImmutableList<RexLiteral>> tuples) {
         final RelTraitSet traits =
-                cluster.traitSetOf(PhoenixRel.CLIENT_CONVENTION)
+                cluster.traitSetOf(PhoenixConvention.CLIENT)
                 .replaceIfs(RelCollationTraitDef.INSTANCE,
                         new Supplier<List<RelCollation>>() {
                     public List<RelCollation> get() {

http://git-wip-us.apache.org/repos/asf/phoenix/blob/50e4406d/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixCompactClientSortRule.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixCompactClientSortRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixCompactClientSortRule.java
index b0f3a9f..b7af899 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixCompactClientSortRule.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixCompactClientSortRule.java
@@ -9,14 +9,13 @@ import org.apache.phoenix.calcite.rel.PhoenixServerAggregate;
 
 public class PhoenixCompactClientSortRule extends RelOptRule {
     
-    public static final PhoenixCompactClientSortRule SORT_SERVERAGGREGATE = 
-            new PhoenixCompactClientSortRule("PhoenixCompactClientSortRule:sort_serveraggregate", PhoenixServerAggregate.class);
+    public static final PhoenixCompactClientSortRule INSTANCE = 
+            new PhoenixCompactClientSortRule();
 
-    public PhoenixCompactClientSortRule(String description, Class<? extends PhoenixRel> clazz) {
+    public PhoenixCompactClientSortRule() {
         super(
             operand(PhoenixClientSort.class, 
-                    operand(clazz, any())),
-            description);
+                    operand(PhoenixServerAggregate.class, any())));
     }
 
     @Override