Repository: phoenix Updated Branches: refs/heads/calcite 229f4c706 -> 36a31bf90
http://git-wip-us.apache.org/repos/asf/phoenix/blob/36a31bf9/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 index b369e48..b2c991f 100644 --- 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 @@ -3,7 +3,6 @@ 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; @@ -12,11 +11,12 @@ 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 = + private static final Predicate<Sort> APPLICABLE_SORT = new Predicate<Sort>() { @Override public boolean apply(Sort input) { - return !input.getCollation().getFieldCollations().isEmpty(); + return !input.getCollation().getFieldCollations().isEmpty() + && input.offset == null && input.fetch == null; } }; @@ -29,7 +29,7 @@ public class PhoenixForwardTableScanRule extends RelOptRule { }; public PhoenixForwardTableScanRule(Class<? extends Sort> sortClass) { - super(operand(sortClass, null, NON_EMPTY_COLLATION, + super(operand(sortClass, null, APPLICABLE_SORT, operand(PhoenixTableScan.class, null, APPLICABLE_TABLE_SCAN, any())), PhoenixForwardTableScanRule.class.getName() + ":" + sortClass.getName()); } @@ -45,11 +45,6 @@ public class PhoenixForwardTableScanRule extends RelOptRule { RelNode newRel = PhoenixTableScan.create( scan.getCluster(), scan.getTable(), scan.filter, ScanOrder.FORWARD, scan.extendedColumnRef); - 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/36a31bf9/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 bf010ce..3c65a0c 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 @@ -4,6 +4,7 @@ import java.util.List; import org.apache.calcite.plan.RelOptRule; import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.logical.LogicalAggregate; import org.apache.phoenix.calcite.rel.PhoenixAbstractAggregate; import org.apache.phoenix.calcite.rel.PhoenixAbstractJoin; import org.apache.phoenix.calcite.rel.PhoenixConvention; @@ -14,10 +15,10 @@ import com.google.common.base.Predicate; public class PhoenixJoinSingleValueAggregateMergeRule extends RelOptRule { /** Predicate that returns true if the Aggregate is solely SINGLE_VALUE check. */ - private static final Predicate<PhoenixAbstractAggregate> IS_SINGLE_VALUE_CHECK_AGGREGATE = - new Predicate<PhoenixAbstractAggregate>() { + private static final Predicate<LogicalAggregate> IS_SINGLE_VALUE_CHECK_AGGREGATE = + new Predicate<LogicalAggregate>() { @Override - public boolean apply(PhoenixAbstractAggregate phoenixAggregate) { + public boolean apply(LogicalAggregate phoenixAggregate) { if (!PhoenixAbstractAggregate.isSingleValueCheckAggregate(phoenixAggregate)) return false; @@ -44,7 +45,7 @@ public class PhoenixJoinSingleValueAggregateMergeRule extends RelOptRule { operand( PhoenixRel.class, any()), operand( - PhoenixAbstractAggregate.class, null, IS_SINGLE_VALUE_CHECK_AGGREGATE, any())), + LogicalAggregate.class, null, IS_SINGLE_VALUE_CHECK_AGGREGATE, any())), "PhoenixJoinSingleValueAggregateMergeRule"); } @@ -52,7 +53,7 @@ public class PhoenixJoinSingleValueAggregateMergeRule extends RelOptRule { public void onMatch(RelOptRuleCall call) { PhoenixAbstractJoin join = call.rel(0); PhoenixRel left = call.rel(1); - PhoenixAbstractAggregate right = call.rel(2); + LogicalAggregate right = call.rel(2); int groupCount = right.getGroupCount(); for (Integer key : join.joinInfo.rightKeys) { if (key >= groupCount) { http://git-wip-us.apache.org/repos/asf/phoenix/blob/36a31bf9/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 25d7138..090b255 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 @@ -10,6 +10,8 @@ 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.PhoenixConvention; +import org.apache.phoenix.calcite.rel.PhoenixTemporarySort; import com.google.common.base.Predicate; import com.google.common.collect.Lists; @@ -48,9 +50,10 @@ public class PhoenixOrderedAggregateRule extends RelOptRule { fieldCollations.add(new RelFieldCollation(ordinal)); } RelCollation collation = RelCollations.of(fieldCollations); - RelNode newInput = convert( - LogicalSort.create(agg.getInput(), collation, null, null), - agg.getInput().getConvention()); + RelNode input = agg.getInput(); + RelNode newInput = input.getConvention() == PhoenixConvention.SERVER + ? PhoenixTemporarySort.create(input, collation) + : convert(LogicalSort.create(input, collation, null, null), input.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/36a31bf9/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 index 715df8b..1ada415 100644 --- 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 @@ -3,7 +3,6 @@ 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; @@ -17,7 +16,8 @@ public class PhoenixReverseTableScanRule extends RelOptRule { new Predicate<Sort>() { @Override public boolean apply(Sort input) { - return !input.getCollation().getFieldCollations().isEmpty(); + return !input.getCollation().getFieldCollations().isEmpty() + && input.offset == null && input.fetch == null; } }; @@ -49,11 +49,6 @@ public class PhoenixReverseTableScanRule extends RelOptRule { RelNode newRel = PhoenixTableScan.create( scan.getCluster(), scan.getTable(), scan.filter, ScanOrder.REVERSE, scan.extendedColumnRef); - 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/36a31bf9/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 index ef34f89..f219f1c 100644 --- 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 @@ -6,11 +6,11 @@ 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.core.Sort; import org.apache.calcite.rel.metadata.RelMdUtil; import org.apache.calcite.rel.metadata.RelMetadataQuery; 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; @@ -23,17 +23,17 @@ public class PhoenixSortServerJoinTransposeRule extends RelOptRule { || 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()))); + public PhoenixSortServerJoinTransposeRule( + Class<? extends Sort> sortClass, String description) { + super( + operand(sortClass, + operand(PhoenixServerJoin.class, null, INNER_OR_LEFT, any())), + description); } @Override public boolean matches(RelOptRuleCall call) { - final PhoenixServerSort sort = call.rel(0); + final Sort sort = call.rel(0); final PhoenixServerJoin join = call.rel(1); if (!join.getLeft().getConvention().satisfies(PhoenixConvention.SERVER)) { return false; @@ -55,7 +55,7 @@ public class PhoenixSortServerJoinTransposeRule extends RelOptRule { } @Override public void onMatch(RelOptRuleCall call) { - final PhoenixServerSort sort = call.rel(0); + final Sort sort = call.rel(0); final PhoenixServerJoin join = call.rel(1); final RelNode newLeftInput = PhoenixTemporarySort.create( join.getLeft(), sort.getCollation()); http://git-wip-us.apache.org/repos/asf/phoenix/blob/36a31bf9/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectLimitTransposeRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectLimitTransposeRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectLimitTransposeRule.java new file mode 100644 index 0000000..9a94fe0 --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectLimitTransposeRule.java @@ -0,0 +1,37 @@ +package org.apache.phoenix.calcite.rules; + +import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.Project; +import org.apache.calcite.rel.logical.LogicalProject; +import org.apache.phoenix.calcite.rel.Limit; +import org.apache.phoenix.calcite.rel.LogicalLimit; + +import com.google.common.collect.ImmutableList; + +public class ProjectLimitTransposeRule extends RelOptRule { + + public static final ProjectLimitTransposeRule INSTANCE = + new ProjectLimitTransposeRule(); + + private ProjectLimitTransposeRule() { + super( + operand(LogicalProject.class, + operand(LogicalLimit.class, any()))); + } + + public void onMatch(RelOptRuleCall call) { + final Project project = call.rel(0); + final Limit limit = call.rel(1); + RelNode newProject = + project.copy( + project.getTraitSet(), + ImmutableList.of(limit.getInput())); + final Limit newLimit = + limit.copy( + limit.getTraitSet(), + ImmutableList.of(newProject)); + call.transformTo(newLimit); + } +} http://git-wip-us.apache.org/repos/asf/phoenix/blob/36a31bf9/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectSortTransposeRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectSortTransposeRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectSortTransposeRule.java new file mode 100644 index 0000000..fa0abbe --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/ProjectSortTransposeRule.java @@ -0,0 +1,70 @@ +package org.apache.phoenix.calcite.rules; + +import java.util.Map; + +import org.apache.calcite.linq4j.Ord; +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.core.Project; +import org.apache.calcite.rel.core.Sort; +import org.apache.calcite.rel.logical.LogicalProject; +import org.apache.calcite.rel.logical.LogicalSort; +import org.apache.calcite.rex.RexInputRef; +import org.apache.calcite.rex.RexNode; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Maps; + +public class ProjectSortTransposeRule extends RelOptRule { + + public static final ProjectSortTransposeRule INSTANCE = + new ProjectSortTransposeRule(); + + private ProjectSortTransposeRule() { + super( + operand(LogicalProject.class, + operand(LogicalSort.class, any()))); + } + + public void onMatch(RelOptRuleCall call) { + final Project project = call.rel(0); + final Sort sort = call.rel(1); + final RelNode input = sort.getInput(); + + Map<Integer, Integer> targets = Maps.newHashMap(); + for (Ord<? extends RexNode> exp : Ord.zip(project.getProjects())) { + if (exp.e instanceof RexInputRef) { + targets.putIfAbsent(((RexInputRef) exp.e).getIndex(), exp.i); + } + } + ImmutableList.Builder<RelFieldCollation> builder = ImmutableList.builder(); + for (RelFieldCollation field : sort.getCollation().getFieldCollations()) { + int index = field.getFieldIndex(); + Integer newIndex = targets.get(index); + if (newIndex == null) { + return; + } + builder.add(new RelFieldCollation(newIndex, field.direction, field.nullDirection)); + } + RelCollation newCollation = + RelCollationTraitDef.INSTANCE.canonize( + RelCollations.of(builder.build())); + RelNode newProject = + project.copy( + input.getTraitSet().replace(project.getConvention()), + ImmutableList.of(input)); + final Sort newSort = + sort.copy( + sort.getTraitSet().replace(newCollation), + newProject, + newCollation, + sort.offset, + sort.fetch); + call.transformTo(newSort); + } +} http://git-wip-us.apache.org/repos/asf/phoenix/blob/36a31bf9/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/SortSplitRule.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/SortSplitRule.java b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/SortSplitRule.java new file mode 100644 index 0000000..364ed49 --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/calcite/rules/SortSplitRule.java @@ -0,0 +1,40 @@ +package org.apache.phoenix.calcite.rules; + +import com.google.common.base.Predicate; + +import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.Sort; +import org.apache.calcite.rel.logical.LogicalSort; +import org.apache.phoenix.calcite.rel.Limit; +import org.apache.phoenix.calcite.rel.LogicalLimit; + +public class SortSplitRule extends RelOptRule { + + /** Predicate that returns true if a table scan has no filter and is not reverse scan. */ + private static final Predicate<Sort> APPLICABLE_SORT = + new Predicate<Sort>() { + @Override + public boolean apply(Sort input) { + return input.offset != null || input.fetch != null; + } + }; + + public static final SortSplitRule INSTANCE = new SortSplitRule(); + + private SortSplitRule() { + super(operand(LogicalSort.class, null, APPLICABLE_SORT, any())); + } + + @Override + public void onMatch(RelOptRuleCall call) { + Sort sort = call.rel(0); + RelNode input = sort.getCollation().getFieldCollations().isEmpty() + ? sort.getInput() + : LogicalSort.create( + sort.getInput(), sort.getCollation(), null, null); + Limit limit = LogicalLimit.create(input, sort.offset, sort.fetch); + call.transformTo(limit); + } +}
