http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/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 7748709..dee433c 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 @@ -1,19 +1,27 @@ package org.apache.phoenix.calcite.rules; import java.util.Arrays; +import java.util.Iterator; +import java.util.List; import java.util.logging.Logger; import org.apache.calcite.adapter.enumerable.EnumerableConvention; import org.apache.calcite.plan.Convention; import org.apache.calcite.plan.RelOptRule; import org.apache.calcite.plan.RelTrait; +import org.apache.calcite.rel.RelCollation; +import org.apache.calcite.rel.RelCollations; +import org.apache.calcite.rel.RelFieldCollation; import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.RelFieldCollation.Direction; import org.apache.calcite.rel.convert.ConverterRule; import org.apache.calcite.rel.core.Aggregate; import org.apache.calcite.rel.core.Aggregate.Group; import org.apache.calcite.rel.core.AggregateCall; import org.apache.calcite.rel.core.Filter; import org.apache.calcite.rel.core.Join; +import org.apache.calcite.rel.core.JoinInfo; +import org.apache.calcite.rel.core.JoinRelType; import org.apache.calcite.rel.core.Project; import org.apache.calcite.rel.core.Sort; import org.apache.calcite.rel.core.Union; @@ -28,17 +36,24 @@ import org.apache.calcite.util.trace.CalciteTrace; import org.apache.phoenix.calcite.CalciteUtils; import org.apache.phoenix.calcite.rel.PhoenixAbstractAggregate; import org.apache.phoenix.calcite.rel.PhoenixClientAggregate; +import org.apache.phoenix.calcite.rel.PhoenixClientJoin; import org.apache.phoenix.calcite.rel.PhoenixClientProject; import org.apache.phoenix.calcite.rel.PhoenixClientSort; import org.apache.phoenix.calcite.rel.PhoenixFilter; -import org.apache.phoenix.calcite.rel.PhoenixJoin; import org.apache.phoenix.calcite.rel.PhoenixLimit; +import org.apache.phoenix.calcite.rel.PhoenixPostJoinProject; 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.PhoenixServerSort; +import org.apache.phoenix.calcite.rel.PhoenixToClientConverter; import org.apache.phoenix.calcite.rel.PhoenixToEnumerableConverter; import org.apache.phoenix.calcite.rel.PhoenixUnion; import com.google.common.base.Predicate; import com.google.common.base.Predicates; +import com.google.common.collect.Lists; /** * Rules and relational operators for @@ -52,13 +67,22 @@ public class PhoenixConverterRules { public static final RelOptRule[] RULES = { PhoenixToEnumerableConverterRule.INSTANCE, - PhoenixSortRule.INSTANCE, + PhoenixServerToClientConverterRule.INSTANCE, + PhoenixProjectableToClientConverterRule.INSTANCE, + PhoenixClientSortRule.INSTANCE, + PhoenixServerSortRule.SERVER, + PhoenixServerSortRule.PROJECTABLE, PhoenixLimitRule.INSTANCE, PhoenixFilterRule.INSTANCE, - PhoenixProjectRule.INSTANCE, - PhoenixAggregateRule.INSTANCE, + PhoenixClientProjectRule.INSTANCE, + PhoenixServerProjectRule.INSTANCE, + PhoenixPostJoinProjectRule.INSTANCE, + PhoenixClientAggregateRule.INSTANCE, + PhoenixServerAggregateRule.SERVER, + PhoenixServerAggregateRule.PROJECTABLE, PhoenixUnionRule.INSTANCE, - PhoenixJoinRule.INSTANCE, + PhoenixClientJoinRule.INSTANCE, + PhoenixServerJoinRule.INSTANCE, }; /** Base class for planner rules that convert a relational expression to @@ -89,36 +113,82 @@ public class PhoenixConverterRules { * Rule to convert a {@link org.apache.calcite.rel.core.Sort} to a * {@link PhoenixClientSort}. */ - private static class PhoenixSortRule extends PhoenixConverterRule { - private static Predicate<LogicalSort> IS_CONVERTIBLE = new Predicate<LogicalSort>() { + private static class PhoenixClientSortRule extends PhoenixConverterRule { + + private static Predicate<Sort> IS_CONVERTIBLE = new Predicate<Sort>() { @Override - public boolean apply(LogicalSort input) { + public boolean apply(Sort input) { return isConvertible(input); } }; - private static Predicate<LogicalSort> SORT_ONLY = new Predicate<LogicalSort>() { + + private static Predicate<Sort> SORT_ONLY = new Predicate<Sort>() { @Override - public boolean apply(LogicalSort input) { + public boolean apply(Sort input) { return !input.getCollation().getFieldCollations().isEmpty() && input.offset == null && input.fetch == null; } }; - public static final PhoenixSortRule INSTANCE = new PhoenixSortRule(); + public static final PhoenixClientSortRule INSTANCE = new PhoenixClientSortRule(); - private PhoenixSortRule() { - super(LogicalSort.class, + private PhoenixClientSortRule() { + super(Sort.class, Predicates.and(Arrays.asList(SORT_ONLY, IS_CONVERTIBLE)), - Convention.NONE, PhoenixRel.CONVENTION, "PhoenixSortRule"); + Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixClientSortRule"); } public RelNode convert(RelNode rel) { - final LogicalSort sort = (LogicalSort) rel; + final Sort sort = (Sort) rel; return PhoenixClientSort.create( convert( sort.getInput(), - sort.getInput().getTraitSet().replace(out)), + sort.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), + sort.getCollation()); + } + } + + /** + * Rule to convert a {@link org.apache.calcite.rel.core.Sort} to a + * {@link PhoenixServerSort}. + */ + private static class PhoenixServerSortRule extends PhoenixConverterRule { + + private static Predicate<Sort> IS_CONVERTIBLE = new Predicate<Sort>() { + @Override + public boolean apply(Sort input) { + return isConvertible(input); + } + }; + + private static Predicate<Sort> SORT_ONLY = new Predicate<Sort>() { + @Override + public boolean apply(Sort input) { + return !input.getCollation().getFieldCollations().isEmpty() + && input.offset == null + && input.fetch == null; + } + }; + + public static final PhoenixServerSortRule SERVER = new PhoenixServerSortRule(PhoenixRel.SERVER_CONVENTION); + public static final PhoenixServerSortRule PROJECTABLE = new PhoenixServerSortRule(PhoenixRel.PROJECTABLE_CONVENTION); + + private final Convention inputConvention; + + private PhoenixServerSortRule(Convention inputConvention) { + super(Sort.class, + Predicates.and(Arrays.asList(SORT_ONLY, IS_CONVERTIBLE)), + Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixServerSortRule:" + inputConvention.getName()); + this.inputConvention = inputConvention; + } + + public RelNode convert(RelNode rel) { + final Sort sort = (Sort) rel; + return PhoenixServerSort.create( + convert( + sort.getInput(), + sort.getInput().getTraitSet().replace(inputConvention)), sort.getCollation()); } } @@ -128,15 +198,15 @@ public class PhoenixConverterRules { * {@link PhoenixLimit}. */ private static class PhoenixLimitRule extends PhoenixConverterRule { - private static Predicate<LogicalSort> IS_CONVERTIBLE = new Predicate<LogicalSort>() { + private static Predicate<Sort> IS_CONVERTIBLE = new Predicate<Sort>() { @Override - public boolean apply(LogicalSort input) { + public boolean apply(Sort input) { return isConvertible(input); } }; - private static Predicate<LogicalSort> OFFSET_OR_FETCH = new Predicate<LogicalSort>() { + private static Predicate<Sort> OFFSET_OR_FETCH = new Predicate<Sort>() { @Override - public boolean apply(LogicalSort input) { + public boolean apply(Sort input) { return input.offset != null || input.fetch != null; } @@ -145,21 +215,25 @@ public class PhoenixConverterRules { public static final PhoenixLimitRule INSTANCE = new PhoenixLimitRule(); private PhoenixLimitRule() { - super(LogicalSort.class, + super(Sort.class, Predicates.and(Arrays.asList(OFFSET_OR_FETCH, IS_CONVERTIBLE)), - Convention.NONE, PhoenixRel.CONVENTION, "PhoenixLimitRule"); + Convention.NONE, PhoenixRel.CLIENT_CONVENTION, "PhoenixLimitRule"); } public RelNode convert(RelNode rel) { - final LogicalSort sort = (LogicalSort) rel; - RelNode input = convert( - sort.getInput(), - sort.getInput().getTraitSet().replace(out)); + final Sort sort = (Sort) rel; + RelNode input = sort.getInput(); if (!sort.getCollation().getFieldCollations().isEmpty()) { - input = PhoenixClientSort.create(input, sort.getCollation()); + input = sort.copy( + sort.getTraitSet(), + sort.getInput(), + sort.getCollation(), + null, null); } return PhoenixLimit.create( - input, + convert( + input, + input.getTraitSet().replace(out)), sort.offset, sort.fetch); } @@ -181,7 +255,7 @@ public class PhoenixConverterRules { private PhoenixFilterRule() { super(LogicalFilter.class, IS_CONVERTIBLE, Convention.NONE, - PhoenixRel.CONVENTION, "PhoenixFilterRule"); + PhoenixRel.CLIENT_CONVENTION, "PhoenixFilterRule"); } public RelNode convert(RelNode rel) { @@ -198,7 +272,8 @@ public class PhoenixConverterRules { * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalProject} * to a {@link PhoenixClientProject}. */ - private static class PhoenixProjectRule extends PhoenixConverterRule { + private static class PhoenixClientProjectRule extends PhoenixConverterRule { + private static Predicate<LogicalProject> IS_CONVERTIBLE = new Predicate<LogicalProject>() { @Override public boolean apply(LogicalProject input) { @@ -206,11 +281,11 @@ public class PhoenixConverterRules { } }; - private static final PhoenixProjectRule INSTANCE = new PhoenixProjectRule(); + private static final PhoenixClientProjectRule INSTANCE = new PhoenixClientProjectRule(); - private PhoenixProjectRule() { + private PhoenixClientProjectRule() { super(LogicalProject.class, IS_CONVERTIBLE, Convention.NONE, - PhoenixRel.CONVENTION, "PhoenixProjectRule"); + PhoenixRel.CLIENT_CONVENTION, "PhoenixClientProjectRule"); } public RelNode convert(RelNode rel) { @@ -218,7 +293,69 @@ public class PhoenixConverterRules { return PhoenixClientProject.create( convert( project.getInput(), - project.getInput().getTraitSet().replace(out)), + project.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), + project.getProjects(), + project.getRowType()); + } + } + + /** + * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalProject} + * to a {@link PhoenixServerProject}. + */ + private static class PhoenixServerProjectRule extends PhoenixConverterRule { + + private static Predicate<LogicalProject> IS_CONVERTIBLE = new Predicate<LogicalProject>() { + @Override + public boolean apply(LogicalProject input) { + return isConvertible(input); + } + }; + + private static final PhoenixServerProjectRule INSTANCE = new PhoenixServerProjectRule(); + + private PhoenixServerProjectRule() { + super(LogicalProject.class, IS_CONVERTIBLE, Convention.NONE, + PhoenixRel.SERVER_CONVENTION, "PhoenixServerProjectRule"); + } + + public RelNode convert(RelNode rel) { + final LogicalProject project = (LogicalProject) rel; + return PhoenixServerProject.create( + convert( + project.getInput(), + project.getInput().getTraitSet().replace(PhoenixRel.SERVER_CONVENTION)), + project.getProjects(), + project.getRowType()); + } + } + + /** + * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalProject} + * to a {@link PhoenixPostJoinProject}. + */ + private static class PhoenixPostJoinProjectRule extends PhoenixConverterRule { + + private static Predicate<LogicalProject> IS_CONVERTIBLE = new Predicate<LogicalProject>() { + @Override + public boolean apply(LogicalProject input) { + return isConvertible(input); + } + }; + + private static final PhoenixPostJoinProjectRule INSTANCE = new PhoenixPostJoinProjectRule(); + + private PhoenixPostJoinProjectRule() { + super(LogicalProject.class, IS_CONVERTIBLE, Convention.NONE, + PhoenixRel.PROJECTABLE_CONVENTION, "PhoenixPostJoinProjectRule"); + } + + public RelNode convert(RelNode rel) { + final LogicalProject project = (LogicalProject) rel; + return PhoenixPostJoinProject.create( + convert( + project.getInput(), + project.getInput().getTraitSet().replace(PhoenixRel.PROJECTABLE_CONVENTION)), project.getProjects(), project.getRowType()); } @@ -228,7 +365,8 @@ public class PhoenixConverterRules { * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalAggregate} * to an {@link PhoenixClientAggregate}. */ - private static class PhoenixAggregateRule extends PhoenixConverterRule { + private static class PhoenixClientAggregateRule extends PhoenixConverterRule { + private static Predicate<LogicalAggregate> IS_CONVERTIBLE = new Predicate<LogicalAggregate>() { @Override public boolean apply(LogicalAggregate input) { @@ -236,11 +374,11 @@ public class PhoenixConverterRules { } }; - public static final RelOptRule INSTANCE = new PhoenixAggregateRule(); + public static final RelOptRule INSTANCE = new PhoenixClientAggregateRule(); - private PhoenixAggregateRule() { + private PhoenixClientAggregateRule() { super(LogicalAggregate.class, IS_CONVERTIBLE, Convention.NONE, - PhoenixRel.CONVENTION, "PhoenixAggregateRule"); + PhoenixRel.CLIENT_CONVENTION, "PhoenixClientAggregateRule"); } public RelNode convert(RelNode rel) { @@ -248,7 +386,44 @@ public class PhoenixConverterRules { return PhoenixClientAggregate.create( convert( agg.getInput(), - agg.getInput().getTraitSet().replace(out)), + agg.getInput().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), + agg.indicator, + agg.getGroupSet(), + agg.getGroupSets(), + agg.getAggCallList()); + } + } + + /** + * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalAggregate} + * to an {@link PhoenixServerAggregate}. + */ + private static class PhoenixServerAggregateRule extends PhoenixConverterRule { + + private static Predicate<LogicalAggregate> IS_CONVERTIBLE = new Predicate<LogicalAggregate>() { + @Override + public boolean apply(LogicalAggregate input) { + return isConvertible(input); + } + }; + + public static final RelOptRule SERVER = new PhoenixServerAggregateRule(PhoenixRel.SERVER_CONVENTION); + public static final RelOptRule PROJECTABLE = new PhoenixServerAggregateRule(PhoenixRel.PROJECTABLE_CONVENTION); + + private final Convention inputConvention; + + private PhoenixServerAggregateRule(Convention inputConvention) { + super(LogicalAggregate.class, IS_CONVERTIBLE, Convention.NONE, + PhoenixRel.CLIENT_CONVENTION, "PhoenixServerAggregateRule:" + inputConvention.getName()); + this.inputConvention = inputConvention; + } + + public RelNode convert(RelNode rel) { + final LogicalAggregate agg = (LogicalAggregate) rel; + return PhoenixServerAggregate.create( + convert( + agg.getInput(), + agg.getInput().getTraitSet().replace(inputConvention)), agg.indicator, agg.getGroupSet(), agg.getGroupSets(), @@ -272,7 +447,7 @@ public class PhoenixConverterRules { private PhoenixUnionRule() { super(LogicalUnion.class, IS_CONVERTIBLE, Convention.NONE, - PhoenixRel.CONVENTION, "PhoenixUnionRule"); + PhoenixRel.CLIENT_CONVENTION, "PhoenixUnionRule"); } public RelNode convert(RelNode rel) { @@ -285,34 +460,107 @@ public class PhoenixConverterRules { /** * Rule to convert a {@link org.apache.calcite.rel.core.Join} to a - * {@link PhoenixJoin}. + * {@link PhoenixClientJoin}. */ - private static class PhoenixJoinRule extends PhoenixConverterRule { + private static class PhoenixClientJoinRule extends PhoenixConverterRule { + private static Predicate<LogicalJoin> IS_CONVERTIBLE = new Predicate<LogicalJoin>() { @Override public boolean apply(LogicalJoin input) { return isConvertible(input); } }; - public static final PhoenixJoinRule INSTANCE = new PhoenixJoinRule(); - private PhoenixJoinRule() { - super(LogicalJoin.class, IS_CONVERTIBLE, Convention.NONE, - PhoenixRel.CONVENTION, "PhoenixJoinRule"); + private static final Predicate<LogicalJoin> NO_RIGHT_JOIN = new Predicate<LogicalJoin>() { + @Override + public boolean apply(LogicalJoin input) { + return input.getJoinType() != JoinRelType.RIGHT; + } + }; + + public static final PhoenixClientJoinRule INSTANCE = new PhoenixClientJoinRule(); + + private PhoenixClientJoinRule() { + super(LogicalJoin.class, Predicates.and(Arrays.asList(IS_CONVERTIBLE, NO_RIGHT_JOIN)), Convention.NONE, + PhoenixRel.CLIENT_CONVENTION, "PhoenixClientJoinRule"); } public RelNode convert(RelNode rel) { final LogicalJoin join = (LogicalJoin) rel; - return PhoenixJoin.create( + RelNode left = join.getLeft(); + RelNode right = join.getRight(); + + JoinInfo joinInfo = JoinInfo.of(join.getLeft(), join.getRight(), join.getCondition()); + if (!joinInfo.leftKeys.isEmpty()) { + List<RelFieldCollation> leftFieldCollations = Lists.newArrayList(); + for (Iterator<Integer> iter = joinInfo.leftKeys.iterator(); iter.hasNext();) { + leftFieldCollations.add(new RelFieldCollation(iter.next(), Direction.ASCENDING)); + } + RelCollation leftCollation = RelCollations.of(leftFieldCollations); + left = LogicalSort.create(left, leftCollation, null, null); + + List<RelFieldCollation> rightFieldCollations = Lists.newArrayList(); + for (Iterator<Integer> iter = joinInfo.rightKeys.iterator(); iter.hasNext();) { + rightFieldCollations.add(new RelFieldCollation(iter.next(), Direction.ASCENDING)); + } + RelCollation rightCollation = RelCollations.of(rightFieldCollations); + right = LogicalSort.create(right, rightCollation, null, null); + } + + return PhoenixClientJoin.create( + convert( + left, + left.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), + convert( + right, + right.getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), + join.getCondition(), + join.getJoinType(), + join.getVariablesStopped(), + false); + } + } + + /** + * Rule to convert a {@link org.apache.calcite.rel.core.Join} to a + * {@link PhoenixServerJoin}. + */ + private static class PhoenixServerJoinRule extends PhoenixConverterRule { + + private static Predicate<LogicalJoin> IS_CONVERTIBLE = new Predicate<LogicalJoin>() { + @Override + public boolean apply(LogicalJoin input) { + return isConvertible(input); + } + }; + + private static final Predicate<LogicalJoin> NO_RIGHT_OR_FULL_JOIN = new Predicate<LogicalJoin>() { + @Override + public boolean apply(LogicalJoin input) { + return input.getJoinType() != JoinRelType.RIGHT && input.getJoinType() != JoinRelType.FULL; + } + }; + + public static final PhoenixServerJoinRule INSTANCE = new PhoenixServerJoinRule(); + + private PhoenixServerJoinRule() { + super(LogicalJoin.class, Predicates.and(Arrays.asList(IS_CONVERTIBLE, NO_RIGHT_OR_FULL_JOIN)), Convention.NONE, + PhoenixRel.PROJECTABLE_CONVENTION, "PhoenixServerJoinRule"); + } + + public RelNode convert(RelNode rel) { + final LogicalJoin join = (LogicalJoin) rel; + return PhoenixServerJoin.create( convert( join.getLeft(), - join.getLeft().getTraitSet().replace(out)), + join.getLeft().getTraitSet().replace(PhoenixRel.SERVER_CONVENTION)), convert( join.getRight(), - join.getRight().getTraitSet().replace(out)), + join.getRight().getTraitSet().replace(PhoenixRel.CLIENT_CONVENTION)), join.getCondition(), join.getJoinType(), - join.getVariablesStopped()); + join.getVariablesStopped(), + false); } } @@ -461,6 +709,44 @@ 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#PROJECTABLE_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.PROJECTABLE_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.calcite.adapter.enumerable.EnumerableConvention}. */ @@ -469,7 +755,7 @@ public class PhoenixConverterRules { new PhoenixToEnumerableConverterRule(); private PhoenixToEnumerableConverterRule() { - super(RelNode.class, PhoenixRel.CONVENTION, EnumerableConvention.INSTANCE, + super(RelNode.class, PhoenixRel.CLIENT_CONVENTION, EnumerableConvention.INSTANCE, "PhoenixToEnumerableConverterRule"); }
http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/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 87335ef..d717a1e 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 @@ -4,7 +4,7 @@ import com.google.common.base.Predicate; import org.apache.calcite.plan.RelOptRule; import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.phoenix.calcite.rel.PhoenixFilter; +import org.apache.calcite.rel.core.Filter; import org.apache.phoenix.calcite.rel.PhoenixTableScan; public class PhoenixFilterScanMergeRule extends RelOptRule { @@ -22,13 +22,13 @@ public class PhoenixFilterScanMergeRule extends RelOptRule { private PhoenixFilterScanMergeRule() { super( - operand(PhoenixFilter.class, + operand(Filter.class, operand(PhoenixTableScan.class, null, NO_FILTER, any()))); } @Override public void onMatch(RelOptRuleCall call) { - PhoenixFilter filter = call.rel(0); + Filter 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(), http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerAggregateRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerAggregateRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerAggregateRule.java deleted file mode 100644 index 90ebce7..0000000 --- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerAggregateRule.java +++ /dev/null @@ -1,39 +0,0 @@ -package org.apache.phoenix.calcite.rules; - -import org.apache.calcite.plan.RelOptRule; -import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.phoenix.calcite.rel.PhoenixClientAggregate; -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.PhoenixTableScan; - -public class PhoenixServerAggregateRule extends RelOptRule { - - public static final PhoenixServerAggregateRule AGGREGATE_SCAN = - new PhoenixServerAggregateRule("PhoenixServerAggregateRule:aggregate_scan", PhoenixTableScan.class); - - public static final PhoenixServerAggregateRule AGGREGATE_SERVERJOIN = - new PhoenixServerAggregateRule("PhoenixServerAggregateRule:aggregate_serverjoin", PhoenixServerJoin.class); - - public static final PhoenixServerAggregateRule AGGREGATE_SERVERPROJECT = - new PhoenixServerAggregateRule("PhoenixServerAggregateRule:aggregate_serverproject", PhoenixServerProject.class); - - public PhoenixServerAggregateRule(String description, Class<? extends PhoenixRel> clazz) { - super( - operand(PhoenixClientAggregate.class, - operand(clazz, any())), - description); - } - - @Override - public void onMatch(RelOptRuleCall call) { - PhoenixClientAggregate aggregate = call.rel(0); - PhoenixRel input = call.rel(1); - call.transformTo(PhoenixServerAggregate.create(input, aggregate.indicator, - aggregate.getGroupSet(), aggregate.getGroupSets(), - aggregate.getAggCallList())); - } - -} http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerJoinRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerJoinRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerJoinRule.java deleted file mode 100644 index cf19389..0000000 --- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerJoinRule.java +++ /dev/null @@ -1,54 +0,0 @@ -package org.apache.phoenix.calcite.rules; - -import org.apache.calcite.plan.RelOptRule; -import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.calcite.plan.RelOptRuleOperand; -import org.apache.calcite.rel.core.JoinRelType; -import org.apache.phoenix.calcite.rel.PhoenixJoin; -import org.apache.phoenix.calcite.rel.PhoenixRel; -import org.apache.phoenix.calcite.rel.PhoenixServerJoin; -import org.apache.phoenix.calcite.rel.PhoenixServerProject; -import org.apache.phoenix.calcite.rel.PhoenixTableScan; - -import com.google.common.base.Predicate; - -public class PhoenixServerJoinRule extends RelOptRule { - - /** Predicate that returns true if a join type is not right or full. */ - private static final Predicate<PhoenixJoin> NO_RIGHT_OR_FULL_JOIN = - new Predicate<PhoenixJoin>() { - @Override - public boolean apply(PhoenixJoin phoenixJoin) { - return phoenixJoin.getJoinType() != JoinRelType.RIGHT - && phoenixJoin.getJoinType() != JoinRelType.FULL; - } - }; - - public static final PhoenixServerJoinRule JOIN_SCAN = - new PhoenixServerJoinRule("PhoenixServerJoinRule:join_scan", - operand(PhoenixTableScan.class, any())); - - public static final PhoenixServerJoinRule JOIN_SERVERPROJECT_SCAN = - new PhoenixServerJoinRule("PhoenixServerJoinRule:join_serverproject_scan", - operand(PhoenixServerProject.class, - operand(PhoenixTableScan.class, any()))); - - public PhoenixServerJoinRule(String description, RelOptRuleOperand left) { - super( - operand(PhoenixJoin.class, null, NO_RIGHT_OR_FULL_JOIN, - left, - operand(PhoenixRel.class, any())), - description); - } - - @Override - public void onMatch(RelOptRuleCall call) { - PhoenixJoin join = call.rel(0); - PhoenixRel left = call.rel(1); - PhoenixRel right = call.rel(call.getRelList().size() - 1); - call.transformTo(PhoenixServerJoin.create( - left, right, join.getCondition(), - join.getJoinType(), join.getVariablesStopped(), false)); - } - -} http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerProjectRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerProjectRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerProjectRule.java deleted file mode 100644 index 662acd3..0000000 --- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerProjectRule.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.apache.phoenix.calcite.rules; - -import org.apache.calcite.plan.RelOptRule; -import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.phoenix.calcite.rel.PhoenixClientProject; -import org.apache.phoenix.calcite.rel.PhoenixRel; -import org.apache.phoenix.calcite.rel.PhoenixServerJoin; -import org.apache.phoenix.calcite.rel.PhoenixServerProject; -import org.apache.phoenix.calcite.rel.PhoenixTableScan; - -public class PhoenixServerProjectRule extends RelOptRule { - - public static final PhoenixServerProjectRule PROJECT_SCAN = - new PhoenixServerProjectRule("PhoenixServerProjectRule:project_scan", PhoenixTableScan.class); - - public static final PhoenixServerProjectRule PROJECT_SERVERJOIN = - new PhoenixServerProjectRule("PhoenixServerProjectRule:project_serverjoin", PhoenixServerJoin.class); - - public PhoenixServerProjectRule(String description, Class<? extends PhoenixRel> clazz) { - super( - operand(PhoenixClientProject.class, - operand(clazz, any())), - description); - } - - @Override - public void onMatch(RelOptRuleCall call) { - PhoenixClientProject project = call.rel(0); - PhoenixRel input = call.rel(1); - call.transformTo(PhoenixServerProject.create( - input, project.getProjects(), project.getRowType())); - } - -} http://git-wip-us.apache.org/repos/asf/phoenix/blob/c1396ecf/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerSortRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerSortRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerSortRule.java deleted file mode 100644 index 21959eb..0000000 --- a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/PhoenixServerSortRule.java +++ /dev/null @@ -1,38 +0,0 @@ -package org.apache.phoenix.calcite.rules; - -import org.apache.calcite.plan.RelOptRule; -import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.phoenix.calcite.rel.PhoenixClientSort; -import org.apache.phoenix.calcite.rel.PhoenixRel; -import org.apache.phoenix.calcite.rel.PhoenixServerJoin; -import org.apache.phoenix.calcite.rel.PhoenixServerProject; -import org.apache.phoenix.calcite.rel.PhoenixServerSort; -import org.apache.phoenix.calcite.rel.PhoenixTableScan; - -public class PhoenixServerSortRule extends RelOptRule { - - public static final PhoenixServerSortRule SORT_SCAN = - new PhoenixServerSortRule("PhoenixServerSortRule:sort_scan", PhoenixTableScan.class); - - public static final PhoenixServerSortRule SORT_SERVERJOIN = - new PhoenixServerSortRule("PhoenixServerSortRule:sort_serverjoin", PhoenixServerJoin.class); - - public static final PhoenixServerSortRule SORT_SERVERPROJECT = - new PhoenixServerSortRule("PhoenixServerSortRule:sort_serverproject", PhoenixServerProject.class); - - public PhoenixServerSortRule(String description, Class<? extends PhoenixRel> clazz) { - super( - operand(PhoenixClientSort.class, - operand(clazz, any())), - description); - } - - @Override - public void onMatch(RelOptRuleCall call) { - PhoenixClientSort sort = call.rel(0); - PhoenixRel input = call.rel(1); - call.transformTo(PhoenixServerSort.create( - input, sort.getCollation())); - } - -}