You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by jh...@apache.org on 2014/11/14 22:32:42 UTC
[34/58] [abbrv] [partial] incubator-calcite git commit: [CALCITE-306]
Standardize code style for "import package.*; "
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
index 6d741f7..cb99e86 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
@@ -14,22 +14,36 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
-
-import java.util.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.rex.*;
-import org.eigenbase.util.*;
-import org.eigenbase.util.mapping.*;
-
-import net.hydromatic.optiq.util.BitSets;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexLocalRef;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexProgram;
+import org.apache.calcite.util.BitSets;
+import org.apache.calcite.util.IntList;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Permutation;
+import org.apache.calcite.util.mapping.Mapping;
+import org.apache.calcite.util.mapping.MappingType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
/**
- * PullConstantsThroughAggregatesRule removes constant expressions from the
- * group list of an {@link AggregateRel}.
+ * Planner rule that removes constant expressions from the
+ * group list of an {@link org.apache.calcite.rel.logical.LogicalAggregate}.
*
* <p><b>Effect of the rule</b></p>
*
@@ -38,37 +52,36 @@ import net.hydromatic.optiq.util.BitSets;
* reduced aggregate. If those constants are not used, another rule will remove
* them from the project.
*
- * <p>AggregateRel needs its group columns to be on the prefix of its input
+ * <p>LogicalAggregate needs its group columns to be on the prefix of its input
* relational expression. Therefore, if a constant is not on the trailing edge
* of the group list, removing it will leave a hole. In this case, the rule adds
* a project before the aggregate to reorder the columns, and permutes them back
* afterwards.
*/
-public class PullConstantsThroughAggregatesRule extends RelOptRule {
+public class AggregateProjectPullUpConstantsRule extends RelOptRule {
//~ Static fields/initializers ---------------------------------------------
/** The singleton. */
- public static final PullConstantsThroughAggregatesRule INSTANCE =
- new PullConstantsThroughAggregatesRule();
+ public static final AggregateProjectPullUpConstantsRule INSTANCE =
+ new AggregateProjectPullUpConstantsRule();
//~ Constructors -----------------------------------------------------------
/**
* Private: use singleton
*/
- private PullConstantsThroughAggregatesRule() {
+ private AggregateProjectPullUpConstantsRule() {
super(
- operand(
- AggregateRel.class,
- operand(ProjectRel.class, any())));
+ operand(LogicalAggregate.class,
+ operand(LogicalProject.class, any())));
}
//~ Methods ----------------------------------------------------------------
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- AggregateRel aggregate = call.rel(0);
- ProjectRel child = call.rel(1);
+ LogicalAggregate aggregate = call.rel(0);
+ LogicalProject child = call.rel(1);
final int groupCount = aggregate.getGroupCount();
if (groupCount == 1) {
@@ -78,7 +91,7 @@ public class PullConstantsThroughAggregatesRule extends RelOptRule {
}
final RexProgram program =
- RexProgram.create(child.getChild().getRowType(),
+ RexProgram.create(child.getInput().getRowType(),
child.getProjects(), null, child.getRowType(),
child.getCluster().getRexBuilder());
@@ -124,7 +137,7 @@ public class PullConstantsThroughAggregatesRule extends RelOptRule {
newGroupCount));
}
newAggregate =
- new AggregateRel(
+ new LogicalAggregate(
aggregate.getCluster(),
child,
BitSets.range(newGroupCount),
@@ -169,7 +182,7 @@ public class PullConstantsThroughAggregatesRule extends RelOptRule {
// Aggregate on projection.
newAggregate =
- new AggregateRel(
+ new LogicalAggregate(
aggregate.getCluster(),
project,
BitSets.range(newGroupCount),
@@ -238,4 +251,4 @@ public class PullConstantsThroughAggregatesRule extends RelOptRule {
}
}
-// End PullConstantsThroughAggregatesRule.java
+// End AggregateProjectPullUpConstantsRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
index 78a080a..718063f 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
@@ -14,54 +14,93 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
-
-import java.math.BigDecimal;
-import java.util.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.rex.*;
-import org.eigenbase.sql.*;
-import org.eigenbase.sql.fun.*;
-import org.eigenbase.sql.type.SqlTypeUtil;
-import org.eigenbase.util.*;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptRuleOperand;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.fun.SqlAvgAggFunction;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.fun.SqlSumAggFunction;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.util.CompositeList;
+import org.apache.calcite.util.ImmutableIntList;
+import org.apache.calcite.util.Util;
import com.google.common.collect.ImmutableList;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
/**
- * Rule to reduce aggregates to simpler forms. Currently only AVG(x) to
- * SUM(x)/COUNT(x), but eventually will handle others such as STDDEV.
+ * Planner rule that reduces aggregate functions in
+ * {@link org.apache.calcite.rel.core.Aggregate}s to simpler forms.
+ *
+ * <p>Rewrites:
+ * <ul>
+ *
+ * <li>AVG(x) → SUM(x) / COUNT(x)
+ *
+ * <li>STDDEV_POP(x) → SQRT(
+ * (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ * / COUNT(x))
+ *
+ * <li>STDDEV_SAMP(x) → SQRT(
+ * (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ * / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END)
+ *
+ * <li>VAR_POP(x) → (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ * / COUNT(x)
+ *
+ * <li>VAR_SAMP(x) → (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ * / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END
+ * </ul>
+ *
+ * <p>Since many of these rewrites introduce multiple occurrences of simpler
+ * forms like {@code COUNT(x)}, the rule gathers common sub-expressions as it
+ * goes.
*/
-public class ReduceAggregatesRule extends RelOptRule {
+public class AggregateReduceFunctionsRule extends RelOptRule {
//~ Static fields/initializers ---------------------------------------------
- /**
- * The singleton.
- */
- public static final ReduceAggregatesRule INSTANCE =
- new ReduceAggregatesRule(operand(AggregateRel.class, any()));
+ /** The singleton. */
+ public static final AggregateReduceFunctionsRule INSTANCE =
+ new AggregateReduceFunctionsRule(operand(LogicalAggregate.class, any()));
//~ Constructors -----------------------------------------------------------
- protected ReduceAggregatesRule(RelOptRuleOperand operand) {
+ protected AggregateReduceFunctionsRule(RelOptRuleOperand operand) {
super(operand);
}
//~ Methods ----------------------------------------------------------------
- @Override
- public boolean matches(RelOptRuleCall call) {
+ @Override public boolean matches(RelOptRuleCall call) {
if (!super.matches(call)) {
return false;
}
- AggregateRelBase oldAggRel = (AggregateRelBase) call.rels[0];
+ Aggregate oldAggRel = (Aggregate) call.rels[0];
return containsAvgStddevVarCall(oldAggRel.getAggCallList());
}
public void onMatch(RelOptRuleCall ruleCall) {
- AggregateRelBase oldAggRel = (AggregateRelBase) ruleCall.rels[0];
+ Aggregate oldAggRel = (Aggregate) ruleCall.rels[0];
reduceAggs(ruleCall, oldAggRel);
}
@@ -89,7 +128,7 @@ public class ReduceAggregatesRule extends RelOptRule {
*/
private void reduceAggs(
RelOptRuleCall ruleCall,
- AggregateRelBase oldAggRel) {
+ Aggregate oldAggRel) {
RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder();
List<AggregateCall> oldCalls = oldAggRel.getAggCallList();
@@ -112,7 +151,7 @@ public class ReduceAggregatesRule extends RelOptRule {
// List of input expressions. If a particular aggregate needs more, it
// will add an expression to the end, and we will create an extra
// project.
- RelNode input = oldAggRel.getChild();
+ RelNode input = oldAggRel.getInput();
List<RexNode> inputExprs = new ArrayList<RexNode>();
for (RelDataTypeField field : input.getRowType().getFieldList()) {
inputExprs.add(
@@ -140,7 +179,7 @@ public class ReduceAggregatesRule extends RelOptRule {
extraArgCount,
null)));
}
- AggregateRelBase newAggRel =
+ Aggregate newAggRel =
newAggregateRel(
oldAggRel, input, newCalls);
@@ -159,7 +198,7 @@ public class ReduceAggregatesRule extends RelOptRule {
}
private RexNode reduceAgg(
- AggregateRelBase oldAggRel,
+ Aggregate oldAggRel,
AggregateCall oldCall,
List<AggregateCall> newCalls,
Map<AggregateCall, RexNode> aggCallMapping,
@@ -226,7 +265,7 @@ public class ReduceAggregatesRule extends RelOptRule {
}
private RexNode reduceAvg(
- AggregateRelBase oldAggRel,
+ Aggregate oldAggRel,
AggregateCall oldCall,
List<AggregateCall> newCalls,
Map<AggregateCall, RexNode> aggCallMapping) {
@@ -237,7 +276,7 @@ public class ReduceAggregatesRule extends RelOptRule {
int iAvgInput = oldCall.getArgList().get(0);
RelDataType avgInputType =
getFieldType(
- oldAggRel.getChild(),
+ oldAggRel.getInput(),
iAvgInput);
RelDataType sumType =
typeFactory.createTypeWithNullability(
@@ -257,7 +296,7 @@ public class ReduceAggregatesRule extends RelOptRule {
oldCall.isDistinct(),
oldCall.getArgList(),
oldAggRel.getGroupCount(),
- oldAggRel.getChild(),
+ oldAggRel.getInput(),
null,
null);
@@ -287,7 +326,7 @@ public class ReduceAggregatesRule extends RelOptRule {
}
private RexNode reduceSum(
- AggregateRelBase oldAggRel,
+ Aggregate oldAggRel,
AggregateCall oldCall,
List<AggregateCall> newCalls,
Map<AggregateCall, RexNode> aggCallMapping) {
@@ -298,7 +337,7 @@ public class ReduceAggregatesRule extends RelOptRule {
int arg = oldCall.getArgList().get(0);
RelDataType argType =
getFieldType(
- oldAggRel.getChild(),
+ oldAggRel.getInput(),
arg);
final RelDataType sumType =
typeFactory.createTypeWithNullability(
@@ -350,7 +389,7 @@ public class ReduceAggregatesRule extends RelOptRule {
}
private RexNode reduceStddev(
- AggregateRelBase oldAggRel,
+ Aggregate oldAggRel,
AggregateCall oldCall,
boolean biased,
boolean sqrt,
@@ -377,7 +416,7 @@ public class ReduceAggregatesRule extends RelOptRule {
final int argOrdinal = oldCall.getArgList().get(0);
final RelDataType argType =
getFieldType(
- oldAggRel.getChild(),
+ oldAggRel.getInput(),
argOrdinal);
final RexNode argRef = inputExprs.get(argOrdinal);
@@ -430,7 +469,7 @@ public class ReduceAggregatesRule extends RelOptRule {
oldCall.isDistinct(),
oldCall.getArgList(),
oldAggRel.getGroupCount(),
- oldAggRel.getChild(),
+ oldAggRel.getInput(),
null,
null);
final RexNode countArg =
@@ -507,19 +546,19 @@ public class ReduceAggregatesRule extends RelOptRule {
/**
* Do a shallow clone of oldAggRel and update aggCalls. Could be refactored
- * into AggregateRelBase and subclasses - but it's only needed for some
+ * into Aggregate and subclasses - but it's only needed for some
* subclasses.
*
- * @param oldAggRel AggregateRel to clone.
+ * @param oldAggRel LogicalAggregate to clone.
* @param inputRel Input relational expression
* @param newCalls New list of AggregateCalls
* @return shallow clone with new list of AggregateCalls.
*/
- protected AggregateRelBase newAggregateRel(
- AggregateRelBase oldAggRel,
+ protected Aggregate newAggregateRel(
+ Aggregate oldAggRel,
RelNode inputRel,
List<AggregateCall> newCalls) {
- return new AggregateRel(
+ return new LogicalAggregate(
oldAggRel.getCluster(),
inputRel,
oldAggRel.getGroupSet(),
@@ -533,4 +572,4 @@ public class ReduceAggregatesRule extends RelOptRule {
}
}
-// End ReduceAggregatesRule.java
+// End AggregateReduceFunctionsRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
index 970bded..5c11012 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateRemoveRule.java
@@ -14,41 +14,45 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.logical.LogicalAggregate;
/**
- * Rule to remove an {@link AggregateRel} implementing DISTINCT if the
- * underlying relational expression is already distinct.
+ * Planner rule that removes
+ * a {@link org.apache.calcite.rel.logical.LogicalAggregate}
+ * if it computes no aggregate functions
+ * (that is, it is implementing {@code SELECT DISTINCT})
+ * and the underlying relational expression is already distinct.
*/
-public class RemoveDistinctRule extends RelOptRule {
- public static final RemoveDistinctRule INSTANCE =
- new RemoveDistinctRule();
+public class AggregateRemoveRule extends RelOptRule {
+ public static final AggregateRemoveRule INSTANCE =
+ new AggregateRemoveRule();
//~ Constructors -----------------------------------------------------------
/**
- * Creates a RemoveDistinctRule.
+ * Creates a AggregateRemoveRule.
*/
- private RemoveDistinctRule() {
+ private AggregateRemoveRule() {
// REVIEW jvs 14-Mar-2006: We have to explicitly mention the child here
// to make sure the rule re-fires after the child changes (e.g. via
- // RemoveTrivialProjectRule), since that may change our information
+ // ProjectRemoveRule), since that may change our information
// about whether the child is distinct. If we clean up the inference of
// distinct to make it correct up-front, we can get rid of the reference
// to the child here.
super(
- operand(
- AggregateRel.class,
+ operand(LogicalAggregate.class,
operand(RelNode.class, any())));
}
//~ Methods ----------------------------------------------------------------
public void onMatch(RelOptRuleCall call) {
- AggregateRel distinct = call.rel(0);
+ LogicalAggregate distinct = call.rel(0);
RelNode child = call.rel(1);
if (!distinct.getAggCallList().isEmpty()
|| !child.isKey(distinct.getGroupSet())) {
@@ -65,4 +69,4 @@ public class RemoveDistinctRule extends RelOptRule {
}
}
-// End RemoveDistinctRule.java
+// End AggregateRemoveRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
index 3aeca5a..d511f79 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
@@ -14,43 +14,42 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.BitSet;
-import java.util.List;
-
-import org.eigenbase.rel.AggregateCall;
-import org.eigenbase.rel.AggregateRelBase;
-import org.eigenbase.rel.ProjectRelBase;
-import org.eigenbase.rel.RelNode;
-import org.eigenbase.relopt.RelOptCluster;
-import org.eigenbase.relopt.RelOptLattice;
-import org.eigenbase.relopt.RelOptRule;
-import org.eigenbase.relopt.RelOptRuleCall;
-import org.eigenbase.relopt.RelOptRuleOperand;
-import org.eigenbase.relopt.RelOptTable;
-import org.eigenbase.relopt.RelOptUtil;
-import org.eigenbase.relopt.SubstitutionVisitor;
-import org.eigenbase.reltype.RelDataType;
-import org.eigenbase.sql.SqlAggFunction;
-import org.eigenbase.util.Pair;
-import org.eigenbase.util.mapping.AbstractSourceMapping;
-
-import net.hydromatic.optiq.Table;
-import net.hydromatic.optiq.impl.StarTable;
-import net.hydromatic.optiq.jdbc.OptiqSchema;
-import net.hydromatic.optiq.materialize.Lattice;
-import net.hydromatic.optiq.materialize.TileKey;
-import net.hydromatic.optiq.prepare.OptiqPrepareImpl;
-import net.hydromatic.optiq.prepare.RelOptTableImpl;
-import net.hydromatic.optiq.util.BitSets;
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.materialize.Lattice;
+import org.apache.calcite.materialize.TileKey;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptLattice;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptRuleOperand;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.plan.SubstitutionVisitor;
+import org.apache.calcite.prepare.CalcitePrepareImpl;
+import org.apache.calcite.prepare.RelOptTableImpl;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.schema.Table;
+import org.apache.calcite.schema.impl.StarTable;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.util.BitSets;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.mapping.AbstractSourceMapping;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.BitSet;
+import java.util.List;
+
/**
- * Planner rule that matches an {@link org.eigenbase.rel.AggregateRelBase} on
- * top of a {@link net.hydromatic.optiq.impl.StarTable.StarTableScan}.
+ * Planner rule that matches an {@link org.apache.calcite.rel.core.Aggregate} on
+ * top of a {@link org.apache.calcite.schema.impl.StarTable.StarTableScan}.
*
* <p>This pattern indicates that an aggregate table may exist. The rule asks
* the star table for an aggregate table at the required level of aggregation.
@@ -58,31 +57,30 @@ import com.google.common.collect.Lists;
public class AggregateStarTableRule extends RelOptRule {
public static final AggregateStarTableRule INSTANCE =
new AggregateStarTableRule(
- operand(AggregateRelBase.class,
+ operand(Aggregate.class,
some(operand(StarTable.StarTableScan.class, none()))),
"AggregateStarTableRule");
public static final AggregateStarTableRule INSTANCE2 =
new AggregateStarTableRule(
- operand(AggregateRelBase.class,
- operand(ProjectRelBase.class,
+ operand(Aggregate.class,
+ operand(Project.class,
operand(StarTable.StarTableScan.class, none()))),
"AggregateStarTableRule:project") {
- @Override
- public void onMatch(RelOptRuleCall call) {
- final AggregateRelBase aggregate = call.rel(0);
- final ProjectRelBase project = call.rel(1);
+ @Override public void onMatch(RelOptRuleCall call) {
+ final Aggregate aggregate = call.rel(0);
+ final Project project = call.rel(1);
final StarTable.StarTableScan scan = call.rel(2);
final RelNode rel =
AggregateProjectMergeRule.apply(aggregate, project);
- final AggregateRelBase aggregate2;
- final ProjectRelBase project2;
- if (rel instanceof AggregateRelBase) {
+ final Aggregate aggregate2;
+ final Project project2;
+ if (rel instanceof Aggregate) {
project2 = null;
- aggregate2 = (AggregateRelBase) rel;
- } else if (rel instanceof ProjectRelBase) {
- project2 = (ProjectRelBase) rel;
- aggregate2 = (AggregateRelBase) project2.getChild();
+ aggregate2 = (Aggregate) rel;
+ } else if (rel instanceof Project) {
+ project2 = (Project) rel;
+ aggregate2 = (Aggregate) project2.getInput();
} else {
return;
}
@@ -95,27 +93,26 @@ public class AggregateStarTableRule extends RelOptRule {
super(operand, description);
}
- @Override
- public void onMatch(RelOptRuleCall call) {
- final AggregateRelBase aggregate = call.rel(0);
+ @Override public void onMatch(RelOptRuleCall call) {
+ final Aggregate aggregate = call.rel(0);
final StarTable.StarTableScan scan = call.rel(1);
apply(call, null, aggregate, scan);
}
- protected void apply(RelOptRuleCall call, ProjectRelBase postProject,
- final AggregateRelBase aggregate, StarTable.StarTableScan scan) {
+ protected void apply(RelOptRuleCall call, Project postProject,
+ final Aggregate aggregate, StarTable.StarTableScan scan) {
final RelOptCluster cluster = scan.getCluster();
final RelOptTable table = scan.getTable();
final RelOptLattice lattice = call.getPlanner().getLattice(table);
final List<Lattice.Measure> measures =
lattice.lattice.toMeasures(aggregate.getAggCallList());
- final Pair<OptiqSchema.TableEntry, TileKey> pair =
+ final Pair<CalciteSchema.TableEntry, TileKey> pair =
lattice.getAggregate(call.getPlanner(), aggregate.getGroupSet(),
measures);
if (pair == null) {
return;
}
- final OptiqSchema.TableEntry tableEntry = pair.left;
+ final CalciteSchema.TableEntry tableEntry = pair.left;
final TileKey tileKey = pair.right;
final double rowCount = aggregate.getRows();
final Table aggregateTable = tableEntry.getTable();
@@ -126,14 +123,14 @@ public class AggregateStarTableRule extends RelOptRule {
tableEntry, rowCount);
RelNode rel = aggregateRelOptTable.toRel(RelOptUtil.getContext(cluster));
if (tileKey == null) {
- if (OptiqPrepareImpl.DEBUG) {
+ if (CalcitePrepareImpl.DEBUG) {
System.out.println("Using materialization "
+ aggregateRelOptTable.getQualifiedName()
+ " (exact match)");
}
} else if (!tileKey.dimensions.equals(aggregate.getGroupSet())) {
// Aggregate has finer granularity than we need. Roll up.
- if (OptiqPrepareImpl.DEBUG) {
+ if (CalcitePrepareImpl.DEBUG) {
System.out.println("Using materialization "
+ aggregateRelOptTable.getQualifiedName()
+ ", rolling up " + tileKey.dimensions + " to "
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionAggregateRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionAggregateRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionAggregateRule.java
index e7819f9..f20cd69 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionAggregateRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionAggregateRule.java
@@ -14,39 +14,42 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.List;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalUnion;
import com.google.common.collect.ImmutableList;
+import java.util.List;
+
/**
- * PullUpAggregateAboveUnionRule implements the rule for pulling {@link
- * AggregateRel}s beneath a {@link UnionRel} so two {@link AggregateRel}s that
- * are used to remove duplicates can be combined into a single {@link
- * AggregateRel}.
+ * Planner rule that matches
+ * {@link org.apache.calcite.rel.logical.LogicalAggregate}s beneath a
+ * {@link org.apache.calcite.rel.logical.LogicalUnion} and pulls them up, so
+ * that a single
+ * {@link org.apache.calcite.rel.logical.LogicalAggregate} removes duplicates.
*
- * <p>This rule only handles cases where the {@link UnionRel}s still have only
- * two inputs.
+ * <p>This rule only handles cases where the
+ * {@link org.apache.calcite.rel.logical.LogicalUnion}s
+ * still have only two inputs.
*/
-public class PullUpAggregateAboveUnionRule extends RelOptRule {
- public static final PullUpAggregateAboveUnionRule INSTANCE =
- new PullUpAggregateAboveUnionRule();
+public class AggregateUnionAggregateRule extends RelOptRule {
+ public static final AggregateUnionAggregateRule INSTANCE =
+ new AggregateUnionAggregateRule();
//~ Constructors -----------------------------------------------------------
/**
- * Creates a PullUpAggregateAboveUnionRule.
+ * Creates a AggregateUnionAggregateRule.
*/
- private PullUpAggregateAboveUnionRule() {
+ private AggregateUnionAggregateRule() {
super(
- operand(
- AggregateRel.class,
- operand(
- UnionRel.class,
+ operand(LogicalAggregate.class,
+ operand(LogicalUnion.class,
operand(RelNode.class, any()),
operand(RelNode.class, any()))));
}
@@ -55,28 +58,28 @@ public class PullUpAggregateAboveUnionRule extends RelOptRule {
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- UnionRel unionRel = call.rel(1);
+ LogicalUnion union = call.rel(1);
// If distincts haven't been removed yet, defer invoking this rule
- if (!unionRel.all) {
+ if (!union.all) {
return;
}
- AggregateRel topAggRel = call.rel(0);
- AggregateRel bottomAggRel;
+ LogicalAggregate topAggRel = call.rel(0);
+ LogicalAggregate bottomAggRel;
- // We want to apply this rule on the pattern where the AggregateRel
- // is the second input into the UnionRel first. Hence, that's why the
+ // We want to apply this rule on the pattern where the LogicalAggregate
+ // is the second input into the Union first. Hence, that's why the
// rule pattern matches on generic RelNodes rather than explicit
// UnionRels. By doing so, and firing this rule in a bottom-up order,
// it allows us to only specify a single pattern for this rule.
List<RelNode> unionInputs;
- if (call.rel(3) instanceof AggregateRel) {
+ if (call.rel(3) instanceof LogicalAggregate) {
bottomAggRel = call.rel(3);
unionInputs = ImmutableList.of(
call.rel(2),
call.rel(3).getInput(0));
- } else if (call.rel(2) instanceof AggregateRel) {
+ } else if (call.rel(2) instanceof LogicalAggregate) {
bottomAggRel = call.rel(2);
unionInputs = ImmutableList.of(
call.rel(2).getInput(0),
@@ -91,16 +94,16 @@ public class PullUpAggregateAboveUnionRule extends RelOptRule {
return;
}
- UnionRel newUnionRel =
- new UnionRel(
- unionRel.getCluster(),
+ LogicalUnion newUnion =
+ new LogicalUnion(
+ union.getCluster(),
unionInputs,
true);
- AggregateRel newAggRel =
- new AggregateRel(
+ LogicalAggregate newAggRel =
+ new LogicalAggregate(
topAggRel.getCluster(),
- newUnionRel,
+ newUnion,
topAggRel.getGroupSet(),
topAggRel.getAggCallList());
@@ -108,4 +111,4 @@ public class PullUpAggregateAboveUnionRule extends RelOptRule {
}
}
-// End PullUpAggregateAboveUnionRule.java
+// End AggregateUnionAggregateRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
index 6d8796f..7b92704 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
@@ -14,29 +14,42 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
-
-import java.util.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.rel.metadata.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.sql.SqlAggFunction;
-import org.eigenbase.sql.fun.*;
-
-import net.hydromatic.linq4j.Ord;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalUnion;
+import org.apache.calcite.rel.metadata.RelMdUtil;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.fun.SqlCountAggFunction;
+import org.apache.calcite.sql.fun.SqlMinMaxAggFunction;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.fun.SqlSumAggFunction;
+import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
/**
- * PushAggregateThroughUnionRule implements the rule for pushing an
- * {@link AggregateRel} past a non-distinct {@link UnionRel}.
+ * Planner rule that pushes an
+ * {@link org.apache.calcite.rel.logical.LogicalAggregate}
+ * past a non-distinct {@link org.apache.calcite.rel.logical.LogicalUnion}.
*/
-public class PushAggregateThroughUnionRule extends RelOptRule {
- public static final PushAggregateThroughUnionRule INSTANCE =
- new PushAggregateThroughUnionRule();
+public class AggregateUnionTransposeRule extends RelOptRule {
+ public static final AggregateUnionTransposeRule INSTANCE =
+ new AggregateUnionTransposeRule();
private static final Map<Class, Boolean> SUPPORTED_AGGREGATES =
new IdentityHashMap<Class, Boolean>();
@@ -51,18 +64,17 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
/**
* Private constructor.
*/
- private PushAggregateThroughUnionRule() {
+ private AggregateUnionTransposeRule() {
super(
- operand(
- AggregateRel.class,
- operand(UnionRel.class, any())));
+ operand(LogicalAggregate.class,
+ operand(LogicalUnion.class, any())));
}
public void onMatch(RelOptRuleCall call) {
- AggregateRel aggRel = call.rel(0);
- UnionRel unionRel = call.rel(1);
+ LogicalAggregate aggRel = call.rel(0);
+ LogicalUnion union = call.rel(1);
- if (!unionRel.all) {
+ if (!union.all) {
// This transformation is only valid for UNION ALL.
// Consider t1(i) with rows (5), (5) and t2(i) with
// rows (5), (10), and the query
@@ -75,7 +87,7 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
return;
}
- RelOptCluster cluster = unionRel.getCluster();
+ RelOptCluster cluster = union.getCluster();
List<AggregateCall> transformedAggCalls =
transformAggCalls(aggRel,
@@ -91,7 +103,7 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
// create corresponding aggs on top of each union child
List<RelNode> newUnionInputs = new ArrayList<RelNode>();
- for (RelNode input : unionRel.getInputs()) {
+ for (RelNode input : union.getInputs()) {
boolean alreadyUnique =
RelMdUtil.areColumnsDefinitelyUnique(
input,
@@ -102,7 +114,7 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
} else {
anyTransformed = true;
newUnionInputs.add(
- new AggregateRel(
+ new LogicalAggregate(
cluster, input,
aggRel.getGroupSet(),
aggRel.getAggCallList()));
@@ -117,11 +129,11 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
}
// create a new union whose children are the aggs created above
- UnionRel newUnionRel = new UnionRel(cluster, newUnionInputs, true);
+ LogicalUnion newUnion = new LogicalUnion(cluster, newUnionInputs, true);
- AggregateRel newTopAggRel = new AggregateRel(
+ LogicalAggregate newTopAggRel = new LogicalAggregate(
cluster,
- newUnionRel,
+ newUnion,
aggRel.getGroupSet(),
transformedAggCalls);
@@ -169,4 +181,4 @@ public class PushAggregateThroughUnionRule extends RelOptRule {
}
}
-// End PushAggregateThroughUnionRule.java
+// End AggregateUnionTransposeRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/CalcMergeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/CalcMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/CalcMergeRule.java
index 79a82b1..0b749d3 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/CalcMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/CalcMergeRule.java
@@ -14,36 +14,44 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.core.Calc;
+import org.apache.calcite.rex.RexOver;
+import org.apache.calcite.rex.RexProgram;
+import org.apache.calcite.rex.RexProgramBuilder;
/**
- * Planner rule which merges a {@link CalcRel} onto a {@link CalcRel}. The
- * resulting {@link CalcRel} has the same project list as the upper {@link
- * CalcRel}, but expressed in terms of the lower {@link CalcRel}'s inputs.
+ * Planner rule that merges a
+ * {@link org.apache.calcite.rel.logical.LogicalCalc} onto a
+ * {@link org.apache.calcite.rel.logical.LogicalCalc}.
+ *
+ * <p>The resulting {@link org.apache.calcite.rel.logical.LogicalCalc} has the
+ * same project list as the upper
+ * {@link org.apache.calcite.rel.logical.LogicalCalc}, but expressed in terms of
+ * the lower {@link org.apache.calcite.rel.logical.LogicalCalc}'s inputs.
*/
-public class MergeCalcRule extends RelOptRule {
+public class CalcMergeRule extends RelOptRule {
//~ Static fields/initializers ---------------------------------------------
- public static final MergeCalcRule INSTANCE = new MergeCalcRule();
+ public static final CalcMergeRule INSTANCE = new CalcMergeRule();
//~ Constructors -----------------------------------------------------------
- private MergeCalcRule() {
+ private CalcMergeRule() {
super(
operand(
- CalcRelBase.class,
- operand(CalcRelBase.class, any())));
+ Calc.class,
+ operand(Calc.class, any())));
}
//~ Methods ----------------------------------------------------------------
public void onMatch(RelOptRuleCall call) {
- final CalcRelBase topCalc = call.rel(0);
- final CalcRelBase bottomCalc = call.rel(1);
+ final Calc topCalc = call.rel(0);
+ final Calc bottomCalc = call.rel(1);
// Don't merge a calc which contains windowed aggregates onto a
// calc. That would effectively be pushing a windowed aggregate down
@@ -62,10 +70,10 @@ public class MergeCalcRule extends RelOptRule {
topCalc.getCluster().getRexBuilder());
assert mergedProgram.getOutputRowType()
== topProgram.getOutputRowType();
- final CalcRelBase newCalc =
+ final Calc newCalc =
topCalc.copy(
topCalc.getTraitSet(),
- bottomCalc.getChild(),
+ bottomCalc.getInput(),
mergedProgram,
topCalc.getCollationList());
@@ -79,4 +87,4 @@ public class MergeCalcRule extends RelOptRule {
}
}
-// End MergeCalcRule.java
+// End CalcMergeRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java b/core/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
index faefefa..5797273 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
@@ -14,38 +14,63 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
-
-import java.io.*;
-
-import java.util.*;
-import java.util.logging.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.rex.*;
-import org.eigenbase.util.*;
-
-import net.hydromatic.optiq.util.graph.*;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Calc;
+import org.apache.calcite.rel.logical.LogicalCalc;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexDynamicParam;
+import org.apache.calcite.rex.RexFieldAccess;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexLocalRef;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexProgram;
+import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.util.IntList;
+import org.apache.calcite.util.Util;
+import org.apache.calcite.util.graph.DefaultDirectedGraph;
+import org.apache.calcite.util.graph.DefaultEdge;
+import org.apache.calcite.util.graph.DirectedGraph;
+import org.apache.calcite.util.graph.TopologicalOrderIterator;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
/**
- * CalcRelSplitter operates on a {@link CalcRel} with multiple {@link RexCall}
- * sub-expressions that cannot all be implemented by a single concrete {@link
- * RelNode}.
+ * CalcRelSplitter operates on a
+ * {@link org.apache.calcite.rel.core.Calc} with multiple {@link RexCall}
+ * sub-expressions that cannot all be implemented by a single concrete
+ * {@link RelNode}.
*
* <p>For example, the Java and Fennel calculator do not implement an identical
- * set of operators. The CalcRel can be used to split a single CalcRel with
- * mixed Java- and Fennel-only operators into a tree of CalcRel object that can
+ * set of operators. The Calc can be used to split a single Calc with
+ * mixed Java- and Fennel-only operators into a tree of Calc object that can
* each be individually implemented by either Java or Fennel.and splits it into
- * several CalcRel instances.
+ * several Calc instances.
*
* <p>Currently the splitter is only capable of handling two "rel types". That
- * is, it can deal with Java vs. Fennel CalcRels, but not Java vs. Fennel vs.
- * some other type of CalcRel.
+ * is, it can deal with Java vs. Fennel Calcs, but not Java vs. Fennel vs.
+ * some other type of Calc.
*
- * <p>See {@link org.eigenbase.rel.rules.WindowedAggSplitterRule} for an example
- * of how this class is used.
+ * <p>See {@link ProjectToWindowRule}
+ * for an example of how this class is used.
*/
public abstract class CalcRelSplitter {
//~ Static fields/initializers ---------------------------------------------
@@ -67,11 +92,11 @@ public abstract class CalcRelSplitter {
/**
* Constructs a CalcRelSplitter.
*
- * @param calc CalcRel to split
+ * @param calc Calc to split
* @param relTypes Array of rel types, e.g. {Java, Fennel}. Must be
* distinct.
*/
- CalcRelSplitter(CalcRelBase calc, RelType[] relTypes) {
+ CalcRelSplitter(Calc calc, RelType[] relTypes) {
for (int i = 0; i < relTypes.length; i++) {
assert relTypes[i] != null;
for (int j = 0; j < i; j++) {
@@ -83,7 +108,7 @@ public abstract class CalcRelSplitter {
this.cluster = calc.getCluster();
this.traits = calc.getTraitSet();
this.typeFactory = calc.getCluster().getTypeFactory();
- this.child = calc.getChild();
+ this.child = calc.getInput();
this.relTypes = relTypes;
}
@@ -102,7 +127,7 @@ public abstract class CalcRelSplitter {
// Figure out what level each expression belongs to.
int[] exprLevels = new int[exprs.length];
- // The reltype of a level is given by
+ // The type of a level is given by
// relTypes[levelTypeOrdinals[level]].
int[] levelTypeOrdinals = new int[exprs.length];
@@ -205,8 +230,8 @@ public abstract class CalcRelSplitter {
// Sometimes a level's program merely projects its inputs. We don't
// want these. They cause an explosion in the search space.
- if (rel instanceof CalcRel
- && ((CalcRel) rel).getProgram().isTrivial()) {
+ if (rel instanceof LogicalCalc
+ && ((LogicalCalc) rel).getProgram().isTrivial()) {
rel = rel.getInput(0);
}
@@ -295,7 +320,7 @@ public abstract class CalcRelSplitter {
levelLoop:
for (;; ++level) {
if (level >= levelCount) {
- // This is a new level. We can use any reltype we like.
+ // This is a new level. We can use any type we like.
for (int relTypeOrdinal = 0;
relTypeOrdinal < relTypes.length;
relTypeOrdinal++) {
@@ -305,7 +330,7 @@ public abstract class CalcRelSplitter {
if (relTypes[relTypeOrdinal].canImplement(
expr,
condition)) {
- // Success. We have found a reltype where we can
+ // Success. We have found a type where we can
// implement this expression.
exprLevels[i] = level;
levelTypeOrdinals[level] = relTypeOrdinal;
@@ -346,7 +371,7 @@ public abstract class CalcRelSplitter {
// implement expr. But maybe we could succeed with a new
// level, with all options open?
if (count(relTypesPossibleForTopLevel) >= relTypes.length) {
- // Cannot implement for any reltype.
+ // Cannot implement for any type.
throw Util.newInternal("cannot implement " + expr);
}
levelTypeOrdinals[levelCount] =
@@ -358,7 +383,7 @@ public abstract class CalcRelSplitter {
if (!relTypes[levelTypeOrdinal].canImplement(
expr,
condition)) {
- // Cannot implement this expression in this reltype;
+ // Cannot implement this expression in this type;
// continue to next level.
continue;
}
@@ -603,7 +628,7 @@ public abstract class CalcRelSplitter {
*
* @param exprs Array expressions
* @param exprLevels For each expression, the ordinal of its level
- * @param levelTypeOrdinals For each level, the ordinal of its reltype in
+ * @param levelTypeOrdinals For each level, the ordinal of its type in
* the {@link #relTypes} array
* @param levelCount The number of levels
*/
@@ -618,8 +643,7 @@ public abstract class CalcRelSplitter {
traceWriter.println(program.toString());
for (int level = 0; level < levelCount; level++) {
- traceWriter.println(
- "Rel Level " + level
+ traceWriter.println("Rel Level " + level
+ ", type " + relTypes[levelTypeOrdinals[level]]);
for (int i = 0; i < exprs.length; i++) {
@@ -686,13 +710,13 @@ public abstract class CalcRelSplitter {
* @param relTypeName Name of a {@link RelType}
* @return Whether relational expression can be implemented
*/
- protected boolean canImplement(CalcRel rel, String relTypeName) {
+ protected boolean canImplement(LogicalCalc rel, String relTypeName) {
for (RelType relType : relTypes) {
if (relType.name.equals(relTypeName)) {
return relType.canImplement(rel.getProgram());
}
}
- throw Util.newInternal("unknown reltype " + relTypeName);
+ throw Util.newInternal("unknown type " + relTypeName);
}
/**
@@ -752,7 +776,7 @@ public abstract class CalcRelSplitter {
RelDataType rowType,
RelNode child,
RexProgram program) {
- return new CalcRel(
+ return new LogicalCalc(
cluster,
traits,
child,
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/CalcRemoveRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/CalcRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/CalcRemoveRule.java
index c663105..879b8f2 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/CalcRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/CalcRemoveRule.java
@@ -14,37 +14,41 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.logical.LogicalCalc;
+import org.apache.calcite.rex.RexProgram;
/**
- * Rule which removes a trivial {@link CalcRel}.
+ * Planner rule that removes a trivial
+ * {@link org.apache.calcite.rel.logical.LogicalCalc}.
*
- * <p>A {@link CalcRel} is trivial if it projects its input fields in their
+ * <p>A {@link org.apache.calcite.rel.logical.LogicalCalc}
+ * is trivial if it projects its input fields in their
* original order, and it does not filter.
*
- * @see org.eigenbase.rel.rules.RemoveTrivialProjectRule
+ * @see ProjectRemoveRule
*/
-public class RemoveTrivialCalcRule extends RelOptRule {
+public class CalcRemoveRule extends RelOptRule {
//~ Static fields/initializers ---------------------------------------------
- public static final RemoveTrivialCalcRule INSTANCE =
- new RemoveTrivialCalcRule();
+ public static final CalcRemoveRule INSTANCE =
+ new CalcRemoveRule();
//~ Constructors -----------------------------------------------------------
- private RemoveTrivialCalcRule() {
- super(operand(CalcRel.class, any()));
+ private CalcRemoveRule() {
+ super(operand(LogicalCalc.class, any()));
}
//~ Methods ----------------------------------------------------------------
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- CalcRel calc = call.rel(0);
+ LogicalCalc calc = call.rel(0);
RexProgram program = calc.getProgram();
if (!program.isTrivial()) {
return;
@@ -58,4 +62,4 @@ public class RemoveTrivialCalcRule extends RelOptRule {
}
}
-// End RemoveTrivialCalcRule.java
+// End CalcRemoveRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/CoerceInputsRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/CoerceInputsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/CoerceInputsRule.java
index 5393654..5f489b9 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/CoerceInputsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/CoerceInputsRule.java
@@ -14,15 +14,18 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataType;
import java.util.ArrayList;
import java.util.List;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.*;
-
/**
* CoerceInputsRule precasts inputs to a particular type. This can be used to
* assist operator implementations which impose requirements on their input
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/EmptyPruneRules.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/EmptyPruneRules.java b/core/src/main/java/org/apache/calcite/rel/rules/EmptyPruneRules.java
index a73fa83..9f3cd67 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/EmptyPruneRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/EmptyPruneRules.java
@@ -14,28 +14,43 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.SingleRel;
+import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.Empty;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.Sort;
+import org.apache.calcite.rel.logical.LogicalUnion;
+import org.apache.calcite.rex.RexLiteral;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.RexLiteral;
+import java.util.ArrayList;
+import java.util.List;
-import static org.eigenbase.relopt.RelOptRule.*;
+import static org.apache.calcite.plan.RelOptRule.any;
+import static org.apache.calcite.plan.RelOptRule.none;
+import static org.apache.calcite.plan.RelOptRule.operand;
+import static org.apache.calcite.plan.RelOptRule.some;
+import static org.apache.calcite.plan.RelOptRule.unordered;
/**
* Collection of rules which remove sections of a query plan known never to
* produce any rows.
*
- * @see EmptyRel
+ * @see org.apache.calcite.rel.core.Empty
*/
-public abstract class RemoveEmptyRules {
+public abstract class EmptyPruneRules {
//~ Static fields/initializers ---------------------------------------------
/**
* Rule that removes empty children of a
- * {@link UnionRel}.
+ * {@link org.apache.calcite.rel.logical.LogicalUnion}.
*
* <p>Examples:
*
@@ -47,20 +62,20 @@ public abstract class RemoveEmptyRules {
*/
public static final RelOptRule UNION_INSTANCE =
new RelOptRule(
- operand(UnionRel.class,
- unordered(operand(EmptyRel.class, none()))),
+ operand(LogicalUnion.class,
+ unordered(operand(Empty.class, none()))),
"Union") {
public void onMatch(RelOptRuleCall call) {
- UnionRel union = call.rel(0);
+ LogicalUnion union = call.rel(0);
final List<RelNode> childRels = call.getChildRels(union);
final List<RelNode> newChildRels = new ArrayList<RelNode>();
for (RelNode childRel : childRels) {
- if (!(childRel instanceof EmptyRel)) {
+ if (!(childRel instanceof Empty)) {
newChildRels.add(childRel);
}
}
assert newChildRels.size() < childRels.size()
- : "planner promised us at least one EmptyRel child";
+ : "planner promised us at least one Empty child";
RelNode newRel;
switch (newChildRels.size()) {
case 0:
@@ -75,7 +90,7 @@ public abstract class RemoveEmptyRules {
break;
default:
newRel =
- new UnionRel(
+ new LogicalUnion(
union.getCluster(),
newChildRels,
union.all);
@@ -86,7 +101,7 @@ public abstract class RemoveEmptyRules {
};
/**
- * Rule that converts a {@link ProjectRel}
+ * Rule that converts a {@link org.apache.calcite.rel.logical.LogicalProject}
* to empty if its child is empty.
*
* <p>Examples:
@@ -96,10 +111,10 @@ public abstract class RemoveEmptyRules {
* </ul>
*/
public static final RelOptRule PROJECT_INSTANCE =
- new RemoveEmptySingleRule(ProjectRelBase.class, "PruneEmptyProject");
+ new RemoveEmptySingleRule(Project.class, "PruneEmptyProject");
/**
- * Rule that converts a {@link FilterRel}
+ * Rule that converts a {@link org.apache.calcite.rel.logical.LogicalFilter}
* to empty if its child is empty.
*
* <p>Examples:
@@ -109,10 +124,10 @@ public abstract class RemoveEmptyRules {
* </ul>
*/
public static final RelOptRule FILTER_INSTANCE =
- new RemoveEmptySingleRule(FilterRelBase.class, "PruneEmptyFilter");
+ new RemoveEmptySingleRule(Filter.class, "PruneEmptyFilter");
/**
- * Rule that converts a {@link SortRel}
+ * Rule that converts a {@link org.apache.calcite.rel.core.Sort}
* to empty if its child is empty.
*
* <p>Examples:
@@ -122,10 +137,10 @@ public abstract class RemoveEmptyRules {
* </ul>
*/
public static final RelOptRule SORT_INSTANCE =
- new RemoveEmptySingleRule(SortRel.class, "PruneEmptySort");
+ new RemoveEmptySingleRule(Sort.class, "PruneEmptySort");
/**
- * Rule that converts a {@link SortRel}
+ * Rule that converts a {@link org.apache.calcite.rel.core.Sort}
* to empty if it has {@code LIMIT 0}.
*
* <p>Examples:
@@ -136,10 +151,9 @@ public abstract class RemoveEmptyRules {
*/
public static final RelOptRule SORT_FETCH_ZERO_INSTANCE =
new RelOptRule(
- operand(SortRel.class, any()), "PruneSortLimit0") {
- @Override
- public void onMatch(RelOptRuleCall call) {
- SortRel sort = call.rel(0);
+ operand(Sort.class, any()), "PruneSortLimit0") {
+ @Override public void onMatch(RelOptRuleCall call) {
+ Sort sort = call.rel(0);
if (sort.fetch != null
&& RexLiteral.intValue(sort.fetch) == 0) {
call.transformTo(empty(sort));
@@ -148,7 +162,7 @@ public abstract class RemoveEmptyRules {
};
/**
- * Rule that converts an {@link AggregateRelBase}
+ * Rule that converts an {@link org.apache.calcite.rel.core.Aggregate}
* to empty if its child is empty.
*
* <p>Examples:
@@ -158,10 +172,10 @@ public abstract class RemoveEmptyRules {
* </ul>
*/
public static final RelOptRule AGGREGATE_INSTANCE =
- new RemoveEmptySingleRule(AggregateRelBase.class, "PruneEmptyAggregate");
+ new RemoveEmptySingleRule(Aggregate.class, "PruneEmptyAggregate");
/**
- * Rule that converts a {@link JoinRelBase}
+ * Rule that converts a {@link org.apache.calcite.rel.core.Join}
* to empty if its left child is empty.
*
* <p>Examples:
@@ -172,14 +186,13 @@ public abstract class RemoveEmptyRules {
*/
public static final RelOptRule JOIN_LEFT_INSTANCE =
new RelOptRule(
- operand(JoinRelBase.class,
+ operand(Join.class,
some(
- operand(EmptyRel.class, none()),
+ operand(Empty.class, none()),
operand(RelNode.class, any()))),
"PruneEmptyJoin(left)") {
- @Override
- public void onMatch(RelOptRuleCall call) {
- JoinRelBase join = call.rel(0);
+ @Override public void onMatch(RelOptRuleCall call) {
+ Join join = call.rel(0);
if (join.getJoinType().generatesNullsOnLeft()) {
// "select * from emp right join dept" is not necessarily empty if
// emp is empty
@@ -190,7 +203,7 @@ public abstract class RemoveEmptyRules {
};
/**
- * Rule that converts a {@link JoinRelBase}
+ * Rule that converts a {@link org.apache.calcite.rel.core.Join}
* to empty if its right child is empty.
*
* <p>Examples:
@@ -201,14 +214,13 @@ public abstract class RemoveEmptyRules {
*/
public static final RelOptRule JOIN_RIGHT_INSTANCE =
new RelOptRule(
- operand(JoinRelBase.class,
+ operand(Join.class,
some(
operand(RelNode.class, any()),
- operand(EmptyRel.class, none()))),
+ operand(Empty.class, none()))),
"PruneEmptyJoin(right)") {
- @Override
- public void onMatch(RelOptRuleCall call) {
- JoinRelBase join = call.rel(0);
+ @Override public void onMatch(RelOptRuleCall call) {
+ Join join = call.rel(0);
if (join.getJoinType().generatesNullsOnRight()) {
// "select * from emp left join dept" is not necessarily empty if
// dept is empty
@@ -218,9 +230,10 @@ public abstract class RemoveEmptyRules {
}
};
- /** Creates an {@link EmptyRel} to replace {@code node}. */
- private static EmptyRel empty(RelNode node) {
- return new EmptyRel(node.getCluster(), node.getRowType());
+ /** Creates an {@link org.apache.calcite.rel.core.Empty} to replace
+ * {@code node}. */
+ private static Empty empty(RelNode node) {
+ return new Empty(node.getCluster(), node.getRowType());
}
/** Planner rule that converts a single-rel (e.g. project, sort, aggregate or
@@ -230,7 +243,7 @@ public abstract class RemoveEmptyRules {
String description) {
super(
operand(clazz,
- operand(EmptyRel.class, none())),
+ operand(Empty.class, none())),
description);
}
@@ -241,4 +254,4 @@ public abstract class RemoveEmptyRules {
}
}
-// End RemoveEmptyRules.java
+// End EmptyPruneRules.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/EquiJoin.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/EquiJoin.java b/core/src/main/java/org/apache/calcite/rel/rules/EquiJoin.java
index 884bdbd..d017f1e 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/EquiJoin.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/EquiJoin.java
@@ -14,30 +14,30 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.Set;
-
-import org.eigenbase.rel.JoinInfo;
-import org.eigenbase.rel.JoinRelBase;
-import org.eigenbase.rel.JoinRelType;
-import org.eigenbase.rel.RelNode;
-import org.eigenbase.relopt.RelOptCluster;
-import org.eigenbase.relopt.RelTraitSet;
-import org.eigenbase.rex.RexNode;
-import org.eigenbase.util.ImmutableIntList;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+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.rex.RexNode;
+import org.apache.calcite.util.ImmutableIntList;
import com.google.common.base.Preconditions;
+import java.util.Set;
+
/**
* Base class for any join whose condition is based on column equality.
*/
-public abstract class EquiJoinRel extends JoinRelBase {
+public abstract class EquiJoin extends Join {
public final ImmutableIntList leftKeys;
public final ImmutableIntList rightKeys;
- /** Creates an EquiJoinRel. */
- public EquiJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left,
+ /** Creates an EquiJoin. */
+ public EquiJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left,
RelNode right, RexNode condition, ImmutableIntList leftKeys,
ImmutableIntList rightKeys, JoinRelType joinType,
Set<String> variablesStopped) {
@@ -54,10 +54,9 @@ public abstract class EquiJoinRel extends JoinRelBase {
return rightKeys;
}
- @Override
- public JoinInfo analyzeCondition() {
+ @Override public JoinInfo analyzeCondition() {
return JoinInfo.of(leftKeys, rightKeys);
}
}
-// End EquiJoinRel.java
+// End EquiJoin.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
index a0f3b67..c3a7e25 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
@@ -14,26 +14,31 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.BitSet;
-import java.util.List;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.reltype.RelDataTypeField;
-import org.eigenbase.rex.*;
-
-import net.hydromatic.optiq.util.BitSets;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.RelFactories;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.BitSets;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.BitSet;
+import java.util.List;
+
/**
- * Planner rule that pushes a {@link FilterRelBase}
- * past a {@link AggregateRelBase}.
+ * Planner rule that pushes a {@link org.apache.calcite.rel.core.Filter}
+ * past a {@link org.apache.calcite.rel.core.Aggregate}.
*
- * @see org.eigenbase.rel.rules.AggregateFilterTransposeRule
+ * @see org.apache.calcite.rel.rules.AggregateFilterTransposeRule
*/
public class FilterAggregateTransposeRule extends RelOptRule {
@@ -42,9 +47,9 @@ public class FilterAggregateTransposeRule extends RelOptRule {
*
* <p>It matches any kind of agg. or filter */
public static final FilterAggregateTransposeRule INSTANCE =
- new FilterAggregateTransposeRule(FilterRelBase.class,
+ new FilterAggregateTransposeRule(Filter.class,
RelFactories.DEFAULT_FILTER_FACTORY,
- AggregateRelBase.class);
+ Aggregate.class);
private final RelFactories.FilterFactory filterFactory;
@@ -57,9 +62,9 @@ public class FilterAggregateTransposeRule extends RelOptRule {
* matched in the rule. Similarly {@code aggregateFactory}.</p>
*/
public FilterAggregateTransposeRule(
- Class<? extends FilterRelBase> filterClass,
+ Class<? extends Filter> filterClass,
RelFactories.FilterFactory filterFactory,
- Class<? extends AggregateRelBase> aggregateClass) {
+ Class<? extends Aggregate> aggregateClass) {
super(
operand(filterClass,
operand(aggregateClass, any())));
@@ -70,8 +75,8 @@ public class FilterAggregateTransposeRule extends RelOptRule {
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- final FilterRelBase filterRel = call.rel(0);
- final AggregateRelBase aggRel = call.rel(1);
+ final Filter filterRel = call.rel(0);
+ final Aggregate aggRel = call.rel(1);
final List<RexNode> conditions =
RelOptUtil.conjunctions(filterRel.getCondition());
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/FilterCalcMergeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterCalcMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterCalcMergeRule.java
index a881b62..5257ee6 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterCalcMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterCalcMergeRule.java
@@ -14,41 +14,49 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import java.util.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.logical.LogicalCalc;
+import org.apache.calcite.rel.logical.LogicalFilter;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexProgram;
+import org.apache.calcite.rex.RexProgramBuilder;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.*;
+import java.util.Collections;
/**
- * Planner rule which merges a {@link FilterRel} and a {@link CalcRel}. The
- * result is a {@link CalcRel} whose filter condition is the logical AND of the
- * two.
+ * Planner rule that merges a
+ * {@link org.apache.calcite.rel.logical.LogicalFilter} and a
+ * {@link org.apache.calcite.rel.logical.LogicalCalc}. The
+ * result is a {@link org.apache.calcite.rel.logical.LogicalCalc}
+ * whose filter condition is the logical AND of the two.
*
- * @see MergeFilterOntoCalcRule
+ * @see FilterMergeRule
*/
-public class MergeFilterOntoCalcRule extends RelOptRule {
+public class FilterCalcMergeRule extends RelOptRule {
//~ Static fields/initializers ---------------------------------------------
- public static final MergeFilterOntoCalcRule INSTANCE =
- new MergeFilterOntoCalcRule();
+ public static final FilterCalcMergeRule INSTANCE =
+ new FilterCalcMergeRule();
//~ Constructors -----------------------------------------------------------
- private MergeFilterOntoCalcRule() {
+ private FilterCalcMergeRule() {
super(
operand(
- FilterRelBase.class,
- operand(CalcRel.class, any())));
+ Filter.class,
+ operand(LogicalCalc.class, any())));
}
//~ Methods ----------------------------------------------------------------
public void onMatch(RelOptRuleCall call) {
- final FilterRel filter = call.rel(0);
- final CalcRel calc = call.rel(1);
+ final LogicalFilter filter = call.rel(0);
+ final LogicalCalc calc = call.rel(1);
// Don't merge a filter onto a calc which contains windowed aggregates.
// That would effectively be pushing a multiset down through a filter.
@@ -74,11 +82,11 @@ public class MergeFilterOntoCalcRule extends RelOptRule {
topProgram,
bottomProgram,
rexBuilder);
- final CalcRel newCalc =
- new CalcRel(
+ final LogicalCalc newCalc =
+ new LogicalCalc(
calc.getCluster(),
calc.getTraitSet(),
- calc.getChild(),
+ calc.getInput(),
filter.getRowType(),
mergedProgram,
Collections.<RelCollation>emptyList());
@@ -86,4 +94,4 @@ public class MergeFilterOntoCalcRule extends RelOptRule {
}
}
-// End MergeFilterOntoCalcRule.java
+// End FilterCalcMergeRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
index b169568..9ea4c40 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
@@ -14,34 +14,45 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
-
-import java.util.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.*;
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptRuleOperand;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.core.RelFactories;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexUtil;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.List;
+
/**
- * PushFilterPastJoinRule implements the rule for pushing filters above and
+ * Planner rule that pushes filters above and
* within a join node into the join node and/or its children nodes.
*/
-public abstract class PushFilterPastJoinRule extends RelOptRule {
- public static final PushFilterPastJoinRule FILTER_ON_JOIN =
- new PushFilterIntoJoinRule(true);
+public abstract class FilterJoinRule extends RelOptRule {
+ public static final FilterJoinRule FILTER_ON_JOIN =
+ new FilterIntoJoinRule(true);
/** Dumber version of {@link #FILTER_ON_JOIN}. Not intended for production
* use, but keeps some tests working for which {@code FILTER_ON_JOIN} is too
* smart. */
- public static final PushFilterPastJoinRule DUMB_FILTER_ON_JOIN =
- new PushFilterIntoJoinRule(false);
+ public static final FilterJoinRule DUMB_FILTER_ON_JOIN =
+ new FilterIntoJoinRule(false);
- public static final PushFilterPastJoinRule JOIN =
- new PushDownJoinConditionRule(RelFactories.DEFAULT_FILTER_FACTORY,
+ public static final FilterJoinRule JOIN =
+ new JoinConditionPushRule(RelFactories.DEFAULT_FILTER_FACTORY,
RelFactories.DEFAULT_PROJECT_FACTORY);
/** Whether to try to strengthen join-type. */
@@ -54,10 +65,10 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
//~ Constructors -----------------------------------------------------------
/**
- * Creates a PushFilterPastJoinRule with an explicit root operand and
+ * Creates a FilterJoinRule with an explicit root operand and
* factories.
*/
- protected PushFilterPastJoinRule(RelOptRuleOperand operand, String id,
+ protected FilterJoinRule(RelOptRuleOperand operand, String id,
boolean smart, RelFactories.FilterFactory filterFactory,
RelFactories.ProjectFactory projectFactory) {
super(operand, "PushFilterRule: " + id);
@@ -68,8 +79,8 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
//~ Methods ----------------------------------------------------------------
- protected void perform(RelOptRuleCall call, FilterRelBase filter,
- JoinRelBase join) {
+ protected void perform(RelOptRuleCall call, Filter filter,
+ Join join) {
final List<RexNode> joinFilters =
RelOptUtil.conjunctions(join.getCondition());
final List<RexNode> origJoinFilters = ImmutableList.copyOf(joinFilters);
@@ -114,7 +125,7 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
join,
aboveFilters,
joinType,
- !(join instanceof EquiJoinRel),
+ !(join instanceof EquiJoin),
!joinType.generatesNullsOnLeft(),
!joinType.generatesNullsOnRight(),
joinFilters,
@@ -205,7 +216,7 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
newJoinRel = RelOptUtil.createCastRel(newJoinRel, join.getRowType(),
false, projectFactory);
- // create a FilterRel on top of the join if needed
+ // create a LogicalFilter on top of the join if needed
RelNode newRel =
RelOptUtil.createFilter(newJoinRel, aboveFilters, filterFactory);
@@ -226,12 +237,13 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
* @param joinFilters Filters in join condition
* @param join Join
*
- * @deprecated Use {@link #validateJoinFilters(java.util.List, java.util.List, org.eigenbase.rel.JoinRelBase, org.eigenbase.rel.JoinRelType)};
+ * @deprecated Use
+ * {@link #validateJoinFilters(java.util.List, java.util.List, org.apache.calcite.rel.core.Join, org.apache.calcite.rel.core.JoinRelType)};
* very short-term; will be removed before
- * {@link org.eigenbase.util.Bug#upgrade(String) calcite-0.9.2}.
+ * {@link org.apache.calcite.util.Bug#upgrade(String) calcite-0.9.2}.
*/
protected void validateJoinFilters(List<RexNode> aboveFilters,
- List<RexNode> joinFilters, JoinRelBase join) {
+ List<RexNode> joinFilters, Join join) {
validateJoinFilters(aboveFilters, joinFilters, join, join.getJoinType());
}
@@ -252,52 +264,49 @@ public abstract class PushFilterPastJoinRule extends RelOptRule {
* outer join simplification.
*/
protected void validateJoinFilters(List<RexNode> aboveFilters,
- List<RexNode> joinFilters, JoinRelBase join, JoinRelType joinType) {
+ List<RexNode> joinFilters, Join join, JoinRelType joinType) {
return;
}
/** Rule that pushes parts of the join condition to its inputs. */
- public static class PushDownJoinConditionRule
- extends PushFilterPastJoinRule {
- public PushDownJoinConditionRule(RelFactories.FilterFactory filterFactory,
+ public static class JoinConditionPushRule extends FilterJoinRule {
+ public JoinConditionPushRule(RelFactories.FilterFactory filterFactory,
RelFactories.ProjectFactory projectFactory) {
- super(RelOptRule.operand(JoinRelBase.class, RelOptRule.any()),
- "PushFilterPastJoinRule:no-filter",
+ super(RelOptRule.operand(Join.class, RelOptRule.any()),
+ "FilterJoinRule:no-filter",
true, filterFactory, projectFactory);
}
- @Override
- public void onMatch(RelOptRuleCall call) {
- JoinRelBase join = call.rel(0);
+ @Override public void onMatch(RelOptRuleCall call) {
+ Join join = call.rel(0);
perform(call, null, join);
}
}
/** Rule that tries to push filter expressions into a join
* condition and into the inputs of the join. */
- public static class PushFilterIntoJoinRule extends PushFilterPastJoinRule {
- public PushFilterIntoJoinRule(boolean smart) {
+ public static class FilterIntoJoinRule extends FilterJoinRule {
+ public FilterIntoJoinRule(boolean smart) {
this(smart, RelFactories.DEFAULT_FILTER_FACTORY,
RelFactories.DEFAULT_PROJECT_FACTORY);
}
- public PushFilterIntoJoinRule(boolean smart,
+ public FilterIntoJoinRule(boolean smart,
RelFactories.FilterFactory filterFactory,
RelFactories.ProjectFactory projectFactory) {
super(
- RelOptRule.operand(FilterRelBase.class,
- RelOptRule.operand(JoinRelBase.class, RelOptRule.any())),
- "PushFilterPastJoinRule:filter",
+ RelOptRule.operand(Filter.class,
+ RelOptRule.operand(Join.class, RelOptRule.any())),
+ "FilterJoinRule:filter",
smart, filterFactory, projectFactory);
}
- @Override
- public void onMatch(RelOptRuleCall call) {
- FilterRelBase filter = call.rel(0);
- JoinRelBase join = call.rel(1);
+ @Override public void onMatch(RelOptRuleCall call) {
+ Filter filter = call.rel(0);
+ Join join = call.rel(1);
perform(call, filter, join);
}
}
}
-// End PushFilterPastJoinRule.java
+// End FilterJoinRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/FilterMergeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterMergeRule.java
index b059bc0..418e5c8 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterMergeRule.java
@@ -14,30 +14,37 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
-import org.eigenbase.rex.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.RelFactories;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexProgram;
+import org.apache.calcite.rex.RexProgramBuilder;
+import org.apache.calcite.rex.RexUtil;
/**
- * MergeFilterRule implements the rule for combining two {@link FilterRel}s
+ * Planner rule that combines two
+ * {@link org.apache.calcite.rel.logical.LogicalFilter}s.
*/
-public class MergeFilterRule extends RelOptRule {
- public static final MergeFilterRule INSTANCE =
- new MergeFilterRule(RelFactories.DEFAULT_FILTER_FACTORY);
+public class FilterMergeRule extends RelOptRule {
+ public static final FilterMergeRule INSTANCE =
+ new FilterMergeRule(RelFactories.DEFAULT_FILTER_FACTORY);
private final RelFactories.FilterFactory filterFactory;
//~ Constructors -----------------------------------------------------------
/**
- * Creates a MergeFilterRule.
+ * Creates a FilterMergeRule.
*/
- public MergeFilterRule(RelFactories.FilterFactory filterFactory) {
+ public FilterMergeRule(RelFactories.FilterFactory filterFactory) {
super(
- operand(FilterRelBase.class,
- operand(FilterRelBase.class, any())));
+ operand(Filter.class,
+ operand(Filter.class, any())));
this.filterFactory = filterFactory;
}
@@ -45,12 +52,12 @@ public class MergeFilterRule extends RelOptRule {
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- final FilterRelBase topFilter = call.rel(0);
- final FilterRelBase bottomFilter = call.rel(1);
+ final Filter topFilter = call.rel(0);
+ final Filter bottomFilter = call.rel(1);
// use RexPrograms to merge the two FilterRels into a single program
- // so we can convert the two FilterRel conditions to directly
- // reference the bottom FilterRel's child
+ // so we can convert the two LogicalFilter conditions to directly
+ // reference the bottom LogicalFilter's child
RexBuilder rexBuilder = topFilter.getCluster().getRexBuilder();
RexProgram bottomProgram = createProgram(bottomFilter);
RexProgram topProgram = createProgram(topFilter);
@@ -65,21 +72,21 @@ public class MergeFilterRule extends RelOptRule {
mergedProgram.expandLocalRef(
mergedProgram.getCondition());
- FilterRelBase newFilterRel =
- (FilterRelBase) filterFactory.createFilter(
- bottomFilter.getChild(),
+ Filter newFilterRel =
+ (Filter) filterFactory.createFilter(
+ bottomFilter.getInput(),
RexUtil.flatten(rexBuilder, newCondition));
call.transformTo(newFilterRel);
}
/**
- * Creates a RexProgram corresponding to a FilterRel
+ * Creates a RexProgram corresponding to a LogicalFilter
*
- * @param filterRel the FilterRel
+ * @param filterRel the LogicalFilter
* @return created RexProgram
*/
- private RexProgram createProgram(FilterRelBase filterRel) {
+ private RexProgram createProgram(Filter filterRel) {
RexProgramBuilder programBuilder =
new RexProgramBuilder(
filterRel.getRowType(),
@@ -90,4 +97,4 @@ public class MergeFilterRule extends RelOptRule {
}
}
-// End MergeFilterRule.java
+// End FilterMergeRule.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
index 7c73043..fe446d1 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
@@ -14,53 +14,56 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.rel.rules;
+package org.apache.calcite.rel.rules;
-import org.eigenbase.rel.*;
-import org.eigenbase.relopt.*;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.logical.LogicalFilter;
/**
- * PushFilterIntoMultiJoinRule implements the rule for pushing a {@link
- * FilterRel} into a {@link MultiJoinRel}.
+ * Planner rule that merges a
+ * {@link org.apache.calcite.rel.logical.LogicalFilter}
+ * into a {@link MultiJoin},
+ * creating a richer {@code MultiJoin}.
+ *
+ * @see org.apache.calcite.rel.rules.ProjectMultiJoinMergeRule
*/
-public class PushFilterIntoMultiJoinRule extends RelOptRule {
- public static final PushFilterIntoMultiJoinRule INSTANCE =
- new PushFilterIntoMultiJoinRule();
+public class FilterMultiJoinMergeRule extends RelOptRule {
+ public static final FilterMultiJoinMergeRule INSTANCE =
+ new FilterMultiJoinMergeRule();
//~ Constructors -----------------------------------------------------------
/**
- * Creates a PushFilterIntoMultiJoinRule.
+ * Creates a FilterMultiJoinMergeRule.
*/
- private PushFilterIntoMultiJoinRule() {
+ private FilterMultiJoinMergeRule() {
super(
- operand(
- FilterRel.class,
- operand(MultiJoinRel.class, any())));
+ operand(LogicalFilter.class,
+ operand(MultiJoin.class, any())));
}
//~ Methods ----------------------------------------------------------------
- // implement RelOptRule
public void onMatch(RelOptRuleCall call) {
- FilterRel filterRel = call.rel(0);
- MultiJoinRel multiJoinRel = call.rel(1);
+ LogicalFilter filter = call.rel(0);
+ MultiJoin multiJoin = call.rel(1);
- MultiJoinRel newMultiJoinRel =
- new MultiJoinRel(
- multiJoinRel.getCluster(),
- multiJoinRel.getInputs(),
- multiJoinRel.getJoinFilter(),
- multiJoinRel.getRowType(),
- multiJoinRel.isFullOuterJoin(),
- multiJoinRel.getOuterJoinConditions(),
- multiJoinRel.getJoinTypes(),
- multiJoinRel.getProjFields(),
- multiJoinRel.getJoinFieldRefCountsMap(),
- filterRel.getCondition());
+ MultiJoin newMultiJoin =
+ new MultiJoin(
+ multiJoin.getCluster(),
+ multiJoin.getInputs(),
+ multiJoin.getJoinFilter(),
+ multiJoin.getRowType(),
+ multiJoin.isFullOuterJoin(),
+ multiJoin.getOuterJoinConditions(),
+ multiJoin.getJoinTypes(),
+ multiJoin.getProjFields(),
+ multiJoin.getJoinFieldRefCountsMap(),
+ filter.getCondition());
- call.transformTo(newMultiJoinRel);
+ call.transformTo(newMultiJoin);
}
}
-// End PushFilterIntoMultiJoinRule.java
+// End FilterMultiJoinMergeRule.java