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:49 UTC
[41/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/plan/RelOptLattice.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptLattice.java b/core/src/main/java/org/apache/calcite/plan/RelOptLattice.java
index be7049a..9131ba3 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptLattice.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptLattice.java
@@ -14,20 +14,19 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
+
+import org.apache.calcite.config.CalciteConnectionConfig;
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.materialize.Lattice;
+import org.apache.calcite.materialize.MaterializationService;
+import org.apache.calcite.materialize.TileKey;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.util.Pair;
import java.util.BitSet;
import java.util.List;
-import org.eigenbase.rel.RelNode;
-import org.eigenbase.util.Pair;
-
-import net.hydromatic.optiq.config.OptiqConnectionConfig;
-import net.hydromatic.optiq.jdbc.OptiqSchema;
-import net.hydromatic.optiq.materialize.Lattice;
-import net.hydromatic.optiq.materialize.MaterializationService;
-import net.hydromatic.optiq.materialize.TileKey;
-
/**
* Use of a lattice by the query optimizer.
*/
@@ -70,17 +69,17 @@ public class RelOptLattice {
* @param measureList Calls to aggregate functions
* @return Materialized table
*/
- public Pair<OptiqSchema.TableEntry, TileKey> getAggregate(
+ public Pair<CalciteSchema.TableEntry, TileKey> getAggregate(
RelOptPlanner planner, BitSet groupSet,
List<Lattice.Measure> measureList) {
- final OptiqConnectionConfig config =
- planner.getContext().unwrap(OptiqConnectionConfig.class);
+ final CalciteConnectionConfig config =
+ planner.getContext().unwrap(CalciteConnectionConfig.class);
if (config == null) {
return null;
}
final MaterializationService service = MaterializationService.instance();
boolean create = lattice.auto && config.createMaterializations();
- final OptiqSchema schema = starRelOptTable.unwrap(OptiqSchema.class);
+ final CalciteSchema schema = starRelOptTable.unwrap(CalciteSchema.class);
return service.defineTile(lattice, groupSet, measureList, schema, create,
false);
}
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptListener.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptListener.java b/core/src/main/java/org/apache/calcite/plan/RelOptListener.java
index c3cd375..42109ae 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptListener.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptListener.java
@@ -14,11 +14,12 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
+import org.apache.calcite.rel.RelNode;
-import org.eigenbase.rel.*;
+import java.util.EventListener;
+import java.util.EventObject;
/**
* RelOptListener defines an interface for listening to events which occur
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
index 77883cc..f09e5fd 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
@@ -14,34 +14,39 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.List;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.rel.metadata.DefaultRelMetadataProvider;
-import org.eigenbase.rel.rules.AggregateFilterTransposeRule;
-import org.eigenbase.rel.rules.AggregateProjectMergeRule;
-import org.eigenbase.rel.rules.MergeProjectRule;
-import org.eigenbase.rel.rules.PullUpProjectsAboveJoinRule;
-import org.eigenbase.rel.rules.PushFilterPastJoinRule;
-import org.eigenbase.rel.rules.PushProjectPastFilterRule;
-import org.eigenbase.rex.RexNode;
-import org.eigenbase.rex.RexUtil;
-import org.eigenbase.sql.SqlExplainLevel;
-import org.eigenbase.util.Util;
-import org.eigenbase.util.mapping.Mappings;
-
-import net.hydromatic.optiq.Table;
-import net.hydromatic.optiq.impl.StarTable;
-import net.hydromatic.optiq.prepare.OptiqPrepareImpl;
-import net.hydromatic.optiq.tools.Program;
-import net.hydromatic.optiq.tools.Programs;
+import org.apache.calcite.prepare.CalcitePrepareImpl;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelShuttleImpl;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalTableScan;
+import org.apache.calcite.rel.metadata.DefaultRelMetadataProvider;
+import org.apache.calcite.rel.rules.AggregateFilterTransposeRule;
+import org.apache.calcite.rel.rules.AggregateProjectMergeRule;
+import org.apache.calcite.rel.rules.FilterJoinRule;
+import org.apache.calcite.rel.rules.JoinProjectTransposeRule;
+import org.apache.calcite.rel.rules.ProjectFilterTransposeRule;
+import org.apache.calcite.rel.rules.ProjectMergeRule;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.schema.Table;
+import org.apache.calcite.schema.impl.StarTable;
+import org.apache.calcite.sql.SqlExplainLevel;
+import org.apache.calcite.tools.Program;
+import org.apache.calcite.tools.Programs;
+import org.apache.calcite.util.Util;
+import org.apache.calcite.util.mapping.Mappings;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.List;
+
/**
* Records that a particular query is materialized by a particular table.
*/
@@ -71,9 +76,9 @@ public class RelOptMaterialization {
/**
* Converts a relational expression to one that uses a
- * {@link net.hydromatic.optiq.impl.StarTable}.
+ * {@link org.apache.calcite.schema.impl.StarTable}.
* The relational expression is already in leaf-join-form, per
- * {@link #toLeafJoinForm(org.eigenbase.rel.RelNode)}.
+ * {@link #toLeafJoinForm(org.apache.calcite.rel.RelNode)}.
*/
public static RelNode tryUseStar(RelNode rel,
final RelOptTable starRelOptTable) {
@@ -81,8 +86,7 @@ public class RelOptMaterialization {
assert starTable != null;
RelNode rel2 = rel.accept(
new RelShuttleImpl() {
- @Override
- public RelNode visit(TableAccessRelBase scan) {
+ @Override public RelNode visit(TableScan scan) {
RelOptTable relOptTable = scan.getTable();
final Table table = relOptTable.unwrap(Table.class);
if (table.equals(starTable.tables.get(0))) {
@@ -100,14 +104,13 @@ public class RelOptMaterialization {
return scan;
}
- @Override
- public RelNode visit(JoinRel join) {
+ @Override public RelNode visit(LogicalJoin join) {
for (;;) {
RelNode rel = super.visit(join);
- if (rel == join || !(rel instanceof JoinRel)) {
+ if (rel == join || !(rel instanceof LogicalJoin)) {
return rel;
}
- join = (JoinRel) rel;
+ join = (LogicalJoin) rel;
final ProjectFilterTable left =
ProjectFilterTable.of(join.getLeft());
if (left != null) {
@@ -124,9 +127,9 @@ public class RelOptMaterialization {
}
}
- /** Throws a {@link org.eigenbase.util.Util.FoundOne} containing a
- * {@link org.eigenbase.rel.TableAccessRel} on success.
- * (Yes, an exception for normal operation.) */
+ /** Throws a {@link org.apache.calcite.util.Util.FoundOne} containing
+ * a {@link org.apache.calcite.rel.logical.LogicalTableScan} on
+ * success. (Yes, an exception for normal operation.) */
private void match(ProjectFilterTable left, ProjectFilterTable right,
RelOptCluster cluster) {
final Mappings.TargetMapping leftMapping = left.mapping();
@@ -146,7 +149,7 @@ public class RelOptMaterialization {
Mappings.offsetSource(rightMapping, offset),
leftMapping.getTargetCount()));
final RelNode project = RelOptUtil.createProject(
- new TableAccessRel(cluster, leftRelOptTable),
+ new LogicalTableScan(cluster, leftRelOptTable),
Mappings.asList(mapping.inverse()));
final List<RexNode> conditions = Lists.newArrayList();
if (left.condition != null) {
@@ -170,7 +173,7 @@ public class RelOptMaterialization {
Mappings.offsetSource(leftMapping, offset),
Mappings.offsetTarget(rightMapping, leftCount));
final RelNode project = RelOptUtil.createProject(
- new TableAccessRel(cluster, rightRelOptTable),
+ new LogicalTableScan(cluster, rightRelOptTable),
Mappings.asList(mapping.inverse()));
final List<RexNode> conditions = Lists.newArrayList();
if (left.condition != null) {
@@ -191,7 +194,7 @@ public class RelOptMaterialization {
return rel;
}
final Program program = Programs.hep(
- ImmutableList.of(PushProjectPastFilterRule.INSTANCE,
+ ImmutableList.of(ProjectFilterTransposeRule.INSTANCE,
AggregateProjectMergeRule.INSTANCE,
AggregateFilterTransposeRule.INSTANCE),
false,
@@ -203,28 +206,28 @@ public class RelOptMaterialization {
private static class ProjectFilterTable {
final RexNode condition;
final Mappings.TargetMapping mapping;
- final TableAccessRelBase scan;
+ final TableScan scan;
private ProjectFilterTable(RexNode condition,
- Mappings.TargetMapping mapping, TableAccessRelBase scan) {
+ Mappings.TargetMapping mapping, TableScan scan) {
this.condition = condition;
this.mapping = mapping;
this.scan = Preconditions.checkNotNull(scan);
}
static ProjectFilterTable of(RelNode node) {
- if (node instanceof FilterRelBase) {
- final FilterRelBase filter = (FilterRelBase) node;
- return of2(filter.getCondition(), filter.getChild());
+ if (node instanceof Filter) {
+ final Filter filter = (Filter) node;
+ return of2(filter.getCondition(), filter.getInput());
} else {
return of2(null, node);
}
}
private static ProjectFilterTable of2(RexNode condition, RelNode node) {
- if (node instanceof ProjectRelBase) {
- final ProjectRelBase project = (ProjectRelBase) node;
- return of3(condition, project.getMapping(), project.getChild());
+ if (node instanceof Project) {
+ final Project project = (Project) node;
+ return of3(condition, project.getMapping(), project.getInput());
} else {
return of3(condition, null, node);
}
@@ -232,9 +235,9 @@ public class RelOptMaterialization {
private static ProjectFilterTable of3(RexNode condition,
Mappings.TargetMapping mapping, RelNode node) {
- if (node instanceof TableAccessRelBase) {
+ if (node instanceof TableScan) {
return new ProjectFilterTable(condition, mapping,
- (TableAccessRelBase) node);
+ (TableScan) node);
} else {
return null;
}
@@ -253,25 +256,25 @@ public class RelOptMaterialization {
/**
* Converts a relational expression to a form where
- * {@link org.eigenbase.rel.JoinRel}s are
+ * {@link org.apache.calcite.rel.logical.LogicalJoin}s are
* as close to leaves as possible.
*/
public static RelNode toLeafJoinForm(RelNode rel) {
final Program program = Programs.hep(
ImmutableList.of(
- PullUpProjectsAboveJoinRule.RIGHT_PROJECT,
- PullUpProjectsAboveJoinRule.LEFT_PROJECT,
- PushFilterPastJoinRule.PushFilterIntoJoinRule.FILTER_ON_JOIN,
- MergeProjectRule.INSTANCE),
+ JoinProjectTransposeRule.RIGHT_PROJECT,
+ JoinProjectTransposeRule.LEFT_PROJECT,
+ FilterJoinRule.FilterIntoJoinRule.FILTER_ON_JOIN,
+ ProjectMergeRule.INSTANCE),
false,
new DefaultRelMetadataProvider());
- if (OptiqPrepareImpl.DEBUG) {
+ if (CalcitePrepareImpl.DEBUG) {
System.out.println(
RelOptUtil.dumpPlan(
"before", rel, false, SqlExplainLevel.DIGEST_ATTRIBUTES));
}
final RelNode rel2 = program.run(null, rel, null);
- if (OptiqPrepareImpl.DEBUG) {
+ if (CalcitePrepareImpl.DEBUG) {
System.out.println(
RelOptUtil.dumpPlan(
"after", rel2, false, SqlExplainLevel.DIGEST_ATTRIBUTES));
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptNode.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptNode.java b/core/src/main/java/org/apache/calcite/plan/RelOptNode.java
index 61b7494..4117dd3 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptNode.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptNode.java
@@ -14,11 +14,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.List;
+import org.apache.calcite.rel.type.RelDataType;
-import org.eigenbase.reltype.RelDataType;
+import java.util.List;
/**
* Node in a planner.
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptPlanner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptPlanner.java b/core/src/main/java/org/apache/calcite/plan/RelOptPlanner.java
index 5f0048a..4ce8038 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptPlanner.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptPlanner.java
@@ -14,18 +14,20 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.List;
-import java.util.logging.*;
-import java.util.regex.*;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.metadata.CachingRelMetadataProvider;
+import org.apache.calcite.rel.metadata.RelMetadataProvider;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.CancelFlag;
+import org.apache.calcite.util.trace.CalciteTrace;
-import org.eigenbase.rel.*;
-import org.eigenbase.rel.metadata.*;
-import org.eigenbase.rex.RexBuilder;
-import org.eigenbase.rex.RexNode;
-import org.eigenbase.trace.*;
-import org.eigenbase.util.*;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
/**
* A <code>RelOptPlanner</code> is a query optimizer: it transforms a relational
@@ -35,7 +37,7 @@ import org.eigenbase.util.*;
public interface RelOptPlanner {
//~ Static fields/initializers ---------------------------------------------
- Logger LOGGER = EigenbaseTrace.getPlannerTracer();
+ Logger LOGGER = CalciteTrace.getPlannerTracer();
//~ Methods ----------------------------------------------------------------
@@ -57,8 +59,8 @@ public interface RelOptPlanner {
* Registers a rel trait definition. If the {@link RelTraitDef} has already
* been registered, does nothing.
*
- * @return whether the RelTraitDef was added, as per {@link
- * java.util.Collection#add}
+ * @return whether the RelTraitDef was added, as per
+ * {@link java.util.Collection#add}
*/
boolean addRelTraitDef(RelTraitDef relTraitDef);
@@ -78,22 +80,25 @@ public interface RelOptPlanner {
void clear();
/**
- * Registers a rule. If the rule has already been registered, does nothing.
- * This method should determine if the given rule is a {@link
- * org.eigenbase.rel.convert.ConverterRule} and pass the ConverterRule to
- * all {@link #addRelTraitDef(RelTraitDef) registered} RelTraitDef
+ * Registers a rule.
+ *
+ * <p>If the rule has already been registered, does nothing.
+ * This method determines if the given rule is a
+ * {@link org.apache.calcite.rel.convert.ConverterRule} and pass the
+ * ConverterRule to all
+ * {@link #addRelTraitDef(RelTraitDef) registered} RelTraitDef
* instances.
*
- * @return whether the rule was added, as per {@link
- * java.util.Collection#add}
+ * @return whether the rule was added, as per
+ * {@link java.util.Collection#add}
*/
boolean addRule(RelOptRule rule);
/**
* Removes a rule.
*
- * @return true if the rule was present, as per {@link
- * java.util.Collection#remove(Object)}
+ * @return true if the rule was present, as per
+ * {@link java.util.Collection#remove(Object)}
*/
boolean removeRule(RelOptRule rule);
@@ -146,7 +151,8 @@ public interface RelOptPlanner {
/**
* Defines a pair of relational expressions that are equivalent.
*
- * <p>Typically {@code tableRel} is a {@link TableAccessRel} representing a
+ * <p>Typically {@code tableRel} is a
+ * {@link org.apache.calcite.rel.logical.LogicalTableScan} representing a
* table that is a materialized view and {@code queryRel} is the SQL
* expression that populates that view. The intention is that
* {@code tableRel} is cheaper to evaluate and therefore if the query being
@@ -177,7 +183,8 @@ public interface RelOptPlanner {
RelNode findBestExp();
/**
- * Returns the factory that creates {@link org.eigenbase.relopt.RelOptCost}s.
+ * Returns the factory that creates
+ * {@link org.apache.calcite.plan.RelOptCost}s.
*/
RelOptCostFactory getCostFactory();
@@ -312,7 +319,7 @@ public interface RelOptPlanner {
}
/**
- * Thrown by {@link org.eigenbase.relopt.RelOptPlanner#findBestExp()}.
+ * Thrown by {@link org.apache.calcite.plan.RelOptPlanner#findBestExp()}.
*/
class CannotPlanException extends RuntimeException {
public CannotPlanException(String message) {
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java b/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java
index 96134dd..2cfdf13 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java
@@ -14,9 +14,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import org.eigenbase.rex.RexNode;
+import org.apache.calcite.rex.RexNode;
import com.google.common.collect.ImmutableList;
@@ -71,4 +71,4 @@ public class RelOptPredicateList {
}
}
-// End RelOptPulledUpPredicates.java
+// End RelOptPredicateList.java
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptQuery.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptQuery.java b/core/src/main/java/org/apache/calcite/plan/RelOptQuery.java
index d9404c3..c3bd49f 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptQuery.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptQuery.java
@@ -14,17 +14,19 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rex.RexBuilder;
-import org.eigenbase.rel.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.rex.*;
+import java.util.HashMap;
+import java.util.Map;
/**
- * A <code>RelOptQuery</code> represents a set of {@link RelNode relational
- * expressions} which derive from the same <code>select</code> statement.
+ * A <code>RelOptQuery</code> represents a set of
+ * {@link RelNode relational expressions} which derive from the same
+ * <code>select</code> statement.
*/
public class RelOptQuery {
//~ Static fields/initializers ---------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRule.java b/core/src/main/java/org/apache/calcite/plan/RelOptRule.java
index 1650950..193ca9b 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRule.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRule.java
@@ -14,11 +14,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
-
-import org.eigenbase.rel.*;
+import org.apache.calcite.rel.RelNode;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
@@ -26,13 +24,16 @@ import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.List;
+
/**
* A <code>RelOptRule</code> transforms an expression into another. It has a
* list of {@link RelOptRuleOperand}s, which determine whether the rule can be
* applied to a particular section of the tree.
*
- * <p>The optimizer figures out which rules are applicable, then calls {@link
- * #onMatch} on each of them.</p>
+ * <p>The optimizer figures out which rules are applicable, then calls
+ * {@link #onMatch} on each of them.</p>
*/
public abstract class RelOptRule {
//~ Static fields/initializers ---------------------------------------------
@@ -182,11 +183,11 @@ public abstract class RelOptRule {
* can have a variable number of children. For example, the rule to
* eliminate empty children of a Union would have operands</p>
*
- * <blockquote>Operand(UnionRel, true, Operand(EmptyRel))</blockquote>
+ * <blockquote>Operand(Union, true, Operand(Empty))</blockquote>
*
* <p>and given the relational expressions</p>
*
- * <blockquote>UnionRel(FilterRel, EmptyRel, ProjectRel)</blockquote>
+ * <blockquote>Union(LogicalFilter, Empty, LogicalProject)</blockquote>
*
* <p>would fire the rule with arguments</p>
*
@@ -347,9 +348,9 @@ public abstract class RelOptRule {
* the rule, and before calling {@link #onMatch(RelOptRuleCall)}.
*
* <p>In implementations of {@link RelOptPlanner} which may queue up a
- * matched {@link RelOptRuleCall} for a long time before calling {@link
- * #onMatch(RelOptRuleCall)}, this method is beneficial because it allows
- * the planner to discard rules earlier in the process.
+ * matched {@link RelOptRuleCall} for a long time before calling
+ * {@link #onMatch(RelOptRuleCall)}, this method is beneficial because it
+ * allows the planner to discard rules earlier in the process.
*
* <p>The default implementation of this method returns <code>true</code>.
* It is acceptable for any implementation of this method to give a false
@@ -490,9 +491,8 @@ public abstract class RelOptRule {
description = className.substring(punc + 1);
}
if (description.matches("[0-9]+")) {
- throw new RuntimeException(
- "Derived description of rule class " + className
- + " is an integer, not valid. "
+ throw new RuntimeException("Derived description of rule class "
+ + className + " is an integer, not valid. "
+ "Supply a description manually.");
}
return description;
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
index a81a522..7b36cb9 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
@@ -14,17 +14,18 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
-import java.util.logging.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.trace.*;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.util.trace.CalciteTrace;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
/**
* A <code>RelOptRuleCall</code> is an invocation of a {@link RelOptRule} with a
* set of {@link RelNode relational expression}s as arguments.
@@ -32,7 +33,7 @@ import com.google.common.collect.ImmutableMap;
public abstract class RelOptRuleCall {
//~ Static fields/initializers ---------------------------------------------
- protected static final Logger LOGGER = EigenbaseTrace.getPlannerTracer();
+ protected static final Logger LOGGER = CalciteTrace.getPlannerTracer();
/**
* Generator for {@link #id} values.
@@ -43,7 +44,7 @@ public abstract class RelOptRuleCall {
public final int id;
private final RelOptRuleOperand operand0;
- private final Map<RelNode, List<RelNode>> nodeChildren;
+ private final Map<RelNode, List<RelNode>> nodeInputs;
public final RelOptRule rule;
public final RelNode[] rels;
private final RelOptPlanner planner;
@@ -58,9 +59,9 @@ public abstract class RelOptRuleCall {
* @param operand Root operand
* @param rels Array of relational expressions which matched each
* operand
- * @param nodeChildren For each node which matched with <code>
- * matchAnyChildren</code>=true, a list of the node's
- * children
+ * @param nodeInputs For each node which matched with
+ * {@code matchAnyChildren}=true, a list of the node's
+ * inputs
* @param parents list of parent RelNodes corresponding to the first
* relational expression in the array argument, if known;
* otherwise, null
@@ -69,12 +70,12 @@ public abstract class RelOptRuleCall {
RelOptPlanner planner,
RelOptRuleOperand operand,
RelNode[] rels,
- Map<RelNode, List<RelNode>> nodeChildren,
+ Map<RelNode, List<RelNode>> nodeInputs,
List<RelNode> parents) {
this.id = nextId++;
this.planner = planner;
this.operand0 = operand;
- this.nodeChildren = nodeChildren;
+ this.nodeInputs = nodeInputs;
this.rule = operand.getRule();
this.rels = rels;
this.parents = parents;
@@ -85,8 +86,8 @@ public abstract class RelOptRuleCall {
RelOptPlanner planner,
RelOptRuleOperand operand,
RelNode[] rels,
- Map<RelNode, List<RelNode>> nodeChildren) {
- this(planner, operand, rels, nodeChildren, null);
+ Map<RelNode, List<RelNode>> nodeInputs) {
+ this(planner, operand, rels, nodeInputs, null);
}
//~ Methods ----------------------------------------------------------------
@@ -147,13 +148,13 @@ public abstract class RelOptRuleCall {
* rule.
*
* <p>If the policy of the operand which caused the match is not
- * {@link org.eigenbase.relopt.RelOptRuleOperandChildPolicy#ANY},
+ * {@link org.apache.calcite.plan.RelOptRuleOperandChildPolicy#ANY},
* the children will have their
* own operands and therefore be easily available in the array returned by
* the {@link #getRels} method, so this method returns null.
*
* <p>This method is for
- * {@link org.eigenbase.relopt.RelOptRuleOperandChildPolicy#ANY},
+ * {@link org.apache.calcite.plan.RelOptRuleOperandChildPolicy#ANY},
* which is generally used when a node can have a variable number of
* children, and hence where the matched children are not retrievable by any
* other means.
@@ -162,7 +163,7 @@ public abstract class RelOptRuleCall {
* @return Children of relational expression
*/
public List<RelNode> getChildRels(RelNode rel) {
- return nodeChildren.get(rel);
+ return nodeInputs.get(rel);
}
/**
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java
index c15ecc3..00c4c83 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java
@@ -14,27 +14,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
-
-import org.eigenbase.rel.RelNode;
-import org.eigenbase.util.*;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.util.Util;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
+import java.util.List;
+
/**
- * A <code>RelOptRuleOperand</code> determines whether a {@link
- * org.eigenbase.relopt.RelOptRule} can be applied to a particular expression.
+ * Operand that determines whether a {@link RelOptRule}
+ * can be applied to a particular expression.
*
* <p>For example, the rule to pull a filter up from the left side of a join
- * takes operands: <code>(Join (Filter) (Any))</code>.</p>
+ * takes operands: <code>Join(Filter, Any)</code>.</p>
*
* <p>Note that <code>children</code> means different things if it is empty or
- * it is <code>null</code>: <code>(Join (Filter <b>()</b>) (Any))</code> means
+ * it is <code>null</code>: <code>Join(Filter <b>()</b>, Any)</code> means
* that, to match the rule, <code>Filter</code> must have no operands.</p>
*/
public class RelOptRuleOperand {
@@ -69,7 +69,7 @@ public class RelOptRuleOperand {
* {@link RelOptRule#none()},
* {@link RelOptRule#any},
* {@link RelOptRule#unordered},
- * See {@link org.eigenbase.relopt.RelOptRuleOperandChildren} for more
+ * See {@link org.apache.calcite.plan.RelOptRuleOperandChildren} for more
* details.</p>
*
* @param clazz Class of relational expression to match (must not be null)
@@ -78,7 +78,8 @@ public class RelOptRuleOperand {
*
* @deprecated Use
* {@link #RelOptRuleOperand(Class, RelTrait, com.google.common.base.Predicate, RelOptRuleOperandChildren)};
- * will be removed after {@link Bug#upgrade(String) 0.9.2}
+ * will be removed after
+ * {@link org.apache.calcite.util.Bug#upgrade(String) 0.9.2}
*/
protected <R extends RelNode> RelOptRuleOperand(
Class<? extends R> clazz,
@@ -96,7 +97,7 @@ public class RelOptRuleOperand {
* {@link RelOptRule#none()},
* {@link RelOptRule#any},
* {@link RelOptRule#unordered},
- * See {@link org.eigenbase.relopt.RelOptRuleOperandChildren} for more
+ * See {@link org.apache.calcite.plan.RelOptRuleOperandChildren} for more
* details.</p>
*
* @param clazz Class of relational expression to match (must not be null)
@@ -189,7 +190,7 @@ public class RelOptRuleOperand {
RelOptRuleOperand that = (RelOptRuleOperand) obj;
return (this.clazz == that.clazz)
- && Util.equal(this.trait, that.trait)
+ && com.google.common.base.Objects.equal(this.trait, that.trait)
&& this.children.equals(that.children);
}
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildPolicy.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildPolicy.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildPolicy.java
index 594cd2b..a9bbc68 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildPolicy.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildPolicy.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
/**
* Policy by which operands will be matched by relational expressions with
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java
index 1322da9..da007c6 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java
@@ -14,13 +14,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
import com.google.common.collect.ImmutableList;
/**
- * Children of a {@link org.eigenbase.relopt.RelOptRuleOperand} and the policy
- * for matching them.
+ * Children of a {@link org.apache.calcite.plan.RelOptRuleOperand} and the
+ * policy for matching them.
*
* <p>Often created by calling one of the following methods:
* {@link RelOptRule#some},
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java b/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
index 89f54d6..7a50613 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
/**
* RelOptSamplingParameters represents the parameters necessary to produce a
@@ -74,8 +74,8 @@ public class RelOptSamplingParameters {
* Indicates whether the sample results should be repeatable. Sample results
* are only required to repeat if no changes have been made to the
* relation's content or structure. If the sample is configured to be
- * repeatable, then a user-specified seed value can be obtained via {@link
- * #getRepeatableSeed()}.
+ * repeatable, then a user-specified seed value can be obtained via
+ * {@link #getRepeatableSeed()}.
*
* @return true if the sample results should be repeatable
*/
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptSchema.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptSchema.java b/core/src/main/java/org/apache/calcite/plan/RelOptSchema.java
index 489a40b..1b682ff 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptSchema.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptSchema.java
@@ -14,11 +14,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.List;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.eigenbase.reltype.*;
+import java.util.List;
/**
* A <code>RelOptSchema</code> is a set of {@link RelOptTable} objects.
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptSchemaWithSampling.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptSchemaWithSampling.java b/core/src/main/java/org/apache/calcite/plan/RelOptSchemaWithSampling.java
index 93a281d..77f6716 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptSchemaWithSampling.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptSchemaWithSampling.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
import java.util.List;
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptTable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptTable.java b/core/src/main/java/org/apache/calcite/plan/RelOptTable.java
index bd0fdbc..571fbd1 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptTable.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptTable.java
@@ -14,14 +14,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataType;
-import org.eigenbase.rel.*;
-import org.eigenbase.reltype.*;
-
-import net.hydromatic.linq4j.expressions.Expression;
+import java.util.BitSet;
+import java.util.List;
/**
* Represents a relational dataset in a {@link RelOptSchema}. It has methods to
@@ -56,11 +57,12 @@ public interface RelOptTable {
/**
* Converts this table into a {@link RelNode relational expression}.
*
- * <p>The {@link org.eigenbase.relopt.RelOptPlanner planner} calls this
+ * <p>The {@link org.apache.calcite.plan.RelOptPlanner planner} calls this
* method to convert a table into an initial relational expression,
- * generally something abstract, such as a {@link
- * org.eigenbase.rel.TableAccessRel}, then optimizes this expression by
- * applying {@link org.eigenbase.relopt.RelOptRule rules} to transform it
+ * generally something abstract, such as a
+ * {@link org.apache.calcite.rel.logical.LogicalTableScan},
+ * then optimizes this expression by
+ * applying {@link org.apache.calcite.plan.RelOptRule rules} to transform it
* into more efficient access methods for this table.</p>
*/
RelNode toRel(ToRelContext context);
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
index ec81f86..e188d35 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -14,30 +14,85 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
-
-import java.io.*;
-import java.util.*;
-
-import org.eigenbase.rel.*;
-import org.eigenbase.rel.rules.*;
-import org.eigenbase.reltype.*;
-import org.eigenbase.rex.*;
-import org.eigenbase.sql.*;
-import org.eigenbase.sql.fun.*;
-import org.eigenbase.sql.type.*;
-import org.eigenbase.sql.validate.SqlValidatorUtil;
-import org.eigenbase.util.*;
-import org.eigenbase.util.mapping.*;
-
-import net.hydromatic.linq4j.Ord;
-
-import net.hydromatic.optiq.util.BitSets;
+package org.apache.calcite.plan;
+
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollationImpl;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelVisitor;
+import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.RelFactories;
+import org.apache.calcite.rel.core.SemiJoin;
+import org.apache.calcite.rel.externalize.RelWriterImpl;
+import org.apache.calcite.rel.externalize.RelXmlWriter;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalCalc;
+import org.apache.calcite.rel.logical.LogicalFilter;
+import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.rules.AggregateProjectPullUpConstantsRule;
+import org.apache.calcite.rel.rules.EmptyPruneRules;
+import org.apache.calcite.rel.rules.FilterMergeRule;
+import org.apache.calcite.rel.rules.MultiJoin;
+import org.apache.calcite.rel.rules.ProjectRemoveRule;
+import org.apache.calcite.rel.rules.ProjectToWindowRule;
+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.rel.type.RelDataTypeFieldImpl;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexCorrelVariable;
+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.RexProgramBuilder;
+import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlExplainLevel;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.fun.SqlMinMaxAggFunction;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.MultisetSqlType;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.calcite.util.BitSets;
+import org.apache.calcite.util.Bug;
+import org.apache.calcite.util.Holder;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Permutation;
+import org.apache.calcite.util.Util;
+import org.apache.calcite.util.mapping.Mapping;
+import org.apache.calcite.util.mapping.MappingType;
+import org.apache.calcite.util.mapping.Mappings;
import com.google.common.base.Function;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
/**
* <code>RelOptUtil</code> defines static utility methods for use in optimizing
* {@link RelNode}s.
@@ -93,7 +148,7 @@ public abstract class RelOptUtil {
/**
* Returns a set of variables used by a relational expression or its
* descendants. The set may contain duplicates. The item type is the same as
- * {@link org.eigenbase.rex.RexVariable#getName}
+ * {@link org.apache.calcite.rex.RexVariable#getName}
*/
public static Set<String> getVariablesUsed(RelNode rel) {
final VariableUsedVisitor vuv = new VariableUsedVisitor();
@@ -136,7 +191,7 @@ public abstract class RelOptUtil {
*
* @param type Struct type
* @return List of field types
- * @see org.eigenbase.reltype.RelDataType#getFieldNames()
+ * @see org.apache.calcite.rel.type.RelDataType#getFieldNames()
*/
public static List<RelDataType> getFieldTypeList(final RelDataType type) {
return Lists.transform(type.getFieldList(), GET_TYPE);
@@ -194,12 +249,9 @@ public abstract class RelOptUtil {
return;
}
- String s =
- "Cannot add expression of different type to set:\n"
- + "set type is "
- + expectedRowType.getFullTypeString()
- + "\nexpression type is "
- + actualRowType.getFullTypeString()
+ String s = "Cannot add expression of different type to set:\n"
+ + "set type is " + expectedRowType.getFullTypeString()
+ + "\nexpression type is " + actualRowType.getFullTypeString()
+ "\nset is " + equivalenceClass.toString()
+ "\nexpression is " + newRel.toString();
throw Util.newInternal(s);
@@ -238,11 +290,13 @@ public abstract class RelOptUtil {
/**
* Creates a plan suitable for use in <code>EXISTS</code> or <code>IN</code>
- * statements. See {@link
- * org.eigenbase.sql2rel.SqlToRelConverter#convertExists} Note: this
- * implementation of createExistsPlan is only called from
- * net.sf.farrago.fennel.rel. The last two arguments do not apply to
- * those invocations and can be removed from the method.
+ * statements.
+ *
+ * <p>See {@link org.apache.calcite.sql2rel.SqlToRelConverter#convertExists}
+ *
+ * <p>Note: this implementation of createExistsPlan is only called from
+ * net.sf.farrago.fennel.rel. The last two arguments do not apply to those
+ * invocations and can be removed from the method.
*
* @param cluster Cluster
* @param seekRel A query rel, for example the resulting rel from 'select *
@@ -303,7 +357,7 @@ public abstract class RelOptUtil {
extraName);
ret =
- new AggregateRel(
+ new LogicalAggregate(
ret.getCluster(),
ret,
BitSets.of(),
@@ -317,7 +371,7 @@ public abstract class RelOptUtil {
* Creates a plan suitable for use in <code>EXISTS</code> or <code>IN</code>
* statements.
*
- * @see org.eigenbase.sql2rel.SqlToRelConverter#convertExists
+ * @see org.apache.calcite.sql2rel.SqlToRelConverter#convertExists
*
* @param seekRel A query rel, for example the resulting rel from 'select *
* from emp' or 'values (1,2,3)' or '('Foo', 34)'.
@@ -347,7 +401,7 @@ public abstract class RelOptUtil {
final int keyCount = ret.getRowType().getFieldCount();
if (!needsOuterJoin) {
return Pair.<RelNode, Boolean>of(
- new AggregateRel(cluster, ret, BitSets.range(keyCount),
+ new LogicalAggregate(cluster, ret, BitSets.range(keyCount),
ImmutableList.<AggregateCall>of()),
false);
}
@@ -381,7 +435,7 @@ public abstract class RelOptUtil {
null,
null);
- ret = new AggregateRel(
+ ret = new LogicalAggregate(
cluster,
ret,
BitSets.range(projectedKeyCount),
@@ -398,10 +452,10 @@ public abstract class RelOptUtil {
}
/**
- * Creates a ProjectRel which accomplishes a rename.
+ * Creates a LogicalProject which accomplishes a rename.
*
* @param outputType a row type descriptor whose field names the generated
- * ProjectRel must match
+ * LogicalProject must match
* @param rel the rel whose output is to be renamed; rel.getRowType()
* must be the same as outputType except for field names
* @return generated relational expression
@@ -414,8 +468,8 @@ public abstract class RelOptUtil {
int n = inputFields.size();
List<RelDataTypeField> outputFields = outputType.getFieldList();
- assert outputFields.size() == n : "rename: field count mismatch: in="
- + inputType
+ assert outputFields.size() == n
+ : "rename: field count mismatch: in=" + inputType
+ ", out" + outputType;
List<Pair<RexNode, String>> renames =
@@ -597,8 +651,8 @@ public abstract class RelOptUtil {
}
/**
- * Creates an AggregateRel which removes all duplicates from the result of
- * an underlying rel.
+ * Creates a LogicalAggregate that removes all duplicates from the result of
+ * an underlying relational expression.
*
* @param rel underlying rel
* @return rel implementing SingleValueAgg
@@ -626,7 +680,7 @@ public abstract class RelOptUtil {
null));
}
- return new AggregateRel(
+ return new LogicalAggregate(
rel.getCluster(),
rel,
BitSets.of(),
@@ -634,15 +688,14 @@ public abstract class RelOptUtil {
}
/**
- * Creates an AggregateRel which removes all duplicates from the result of
- * an underlying rel.
+ * Creates a LogicalAggregate that removes all duplicates from the result of
+ * an underlying relational expression.
*
* @param rel underlying rel
* @return rel implementing DISTINCT
*/
- public static RelNode createDistinctRel(
- RelNode rel) {
- return new AggregateRel(
+ public static RelNode createDistinctRel(RelNode rel) {
+ return new LogicalAggregate(
rel.getCluster(),
rel,
BitSets.range(rel.getRowType().getFieldCount()),
@@ -650,9 +703,9 @@ public abstract class RelOptUtil {
}
public static boolean analyzeSimpleEquiJoin(
- JoinRel joinRel,
+ LogicalJoin join,
int[] joinFieldOrdinals) {
- RexNode joinExp = joinRel.getCondition();
+ RexNode joinExp = join.getCondition();
if (joinExp.getKind() != SqlKind.EQUALS) {
return false;
}
@@ -667,7 +720,7 @@ public abstract class RelOptUtil {
}
final int leftFieldCount =
- joinRel.getLeft().getRowType().getFieldCount();
+ join.getLeft().getRowType().getFieldCount();
RexInputRef leftFieldAccess = (RexInputRef) leftComparand;
if (!(leftFieldAccess.getIndex() < leftFieldCount)) {
// left field must access left side of join
@@ -805,33 +858,33 @@ public abstract class RelOptUtil {
}
public static RexNode splitCorrelatedFilterCondition(
- FilterRel filterRel,
+ LogicalFilter filter,
List<RexInputRef> joinKeys,
List<RexNode> correlatedJoinKeys) {
List<RexNode> nonEquiList = new ArrayList<RexNode>();
splitCorrelatedFilterCondition(
- filterRel,
- filterRel.getCondition(),
+ filter,
+ filter.getCondition(),
joinKeys,
correlatedJoinKeys,
nonEquiList);
// Convert the remainders into a list that are AND'ed together.
return RexUtil.composeConjunction(
- filterRel.getCluster().getRexBuilder(), nonEquiList, true);
+ filter.getCluster().getRexBuilder(), nonEquiList, true);
}
public static RexNode splitCorrelatedFilterCondition(
- FilterRel filterRel,
+ LogicalFilter filter,
List<RexNode> joinKeys,
List<RexNode> correlatedJoinKeys,
boolean extractCorrelatedFieldAccess) {
List<RexNode> nonEquiList = new ArrayList<RexNode>();
splitCorrelatedFilterCondition(
- filterRel,
- filterRel.getCondition(),
+ filter,
+ filter.getCondition(),
joinKeys,
correlatedJoinKeys,
nonEquiList,
@@ -839,7 +892,7 @@ public abstract class RelOptUtil {
// Convert the remainders into a list that are AND'ed together.
return RexUtil.composeConjunction(
- filterRel.getCluster().getRexBuilder(), nonEquiList, true);
+ filter.getCluster().getRexBuilder(), nonEquiList, true);
}
private static void splitJoinCondition(
@@ -1136,7 +1189,7 @@ public abstract class RelOptUtil {
}
private static void splitCorrelatedFilterCondition(
- FilterRel filterRel,
+ LogicalFilter filter,
RexNode condition,
List<RexInputRef> joinKeys,
List<RexNode> correlatedJoinKeys,
@@ -1146,7 +1199,7 @@ public abstract class RelOptUtil {
if (call.getOperator() == SqlStdOperatorTable.AND) {
for (RexNode operand : call.getOperands()) {
splitCorrelatedFilterCondition(
- filterRel,
+ filter,
operand,
joinKeys,
correlatedJoinKeys,
@@ -1182,7 +1235,7 @@ public abstract class RelOptUtil {
}
private static void splitCorrelatedFilterCondition(
- FilterRel filterRel,
+ LogicalFilter filter,
RexNode condition,
List<RexNode> joinKeys,
List<RexNode> correlatedJoinKeys,
@@ -1193,7 +1246,7 @@ public abstract class RelOptUtil {
if (call.getOperator() == SqlStdOperatorTable.AND) {
for (RexNode operand : call.getOperands()) {
splitCorrelatedFilterCondition(
- filterRel,
+ filter,
operand,
joinKeys,
correlatedJoinKeys,
@@ -1464,17 +1517,17 @@ public abstract class RelOptUtil {
}
public static void registerAbstractRels(RelOptPlanner planner) {
- planner.addRule(PullConstantsThroughAggregatesRule.INSTANCE);
- planner.addRule(RemoveEmptyRules.UNION_INSTANCE);
- planner.addRule(RemoveEmptyRules.PROJECT_INSTANCE);
- planner.addRule(RemoveEmptyRules.FILTER_INSTANCE);
- planner.addRule(RemoveEmptyRules.SORT_INSTANCE);
- planner.addRule(RemoveEmptyRules.AGGREGATE_INSTANCE);
- planner.addRule(RemoveEmptyRules.JOIN_LEFT_INSTANCE);
- planner.addRule(RemoveEmptyRules.JOIN_RIGHT_INSTANCE);
- planner.addRule(RemoveEmptyRules.SORT_FETCH_ZERO_INSTANCE);
- planner.addRule(WindowedAggSplitterRule.PROJECT);
- planner.addRule(MergeFilterRule.INSTANCE);
+ planner.addRule(AggregateProjectPullUpConstantsRule.INSTANCE);
+ planner.addRule(EmptyPruneRules.UNION_INSTANCE);
+ planner.addRule(EmptyPruneRules.PROJECT_INSTANCE);
+ planner.addRule(EmptyPruneRules.FILTER_INSTANCE);
+ planner.addRule(EmptyPruneRules.SORT_INSTANCE);
+ planner.addRule(EmptyPruneRules.AGGREGATE_INSTANCE);
+ planner.addRule(EmptyPruneRules.JOIN_LEFT_INSTANCE);
+ planner.addRule(EmptyPruneRules.JOIN_RIGHT_INSTANCE);
+ planner.addRule(EmptyPruneRules.SORT_FETCH_ZERO_INSTANCE);
+ planner.addRule(ProjectToWindowRule.PROJECT);
+ planner.addRule(FilterMergeRule.INSTANCE);
}
/**
@@ -1574,9 +1627,9 @@ public abstract class RelOptUtil {
}
/**
- * Returns whether two types are equal using {@link
- * #areRowTypesEqual(RelDataType, RelDataType, boolean)}. Both types must
- * not be null.
+ * Returns whether two types are equal using
+ * {@link #areRowTypesEqual(RelDataType, RelDataType, boolean)}. Both types
+ * must not be null.
*
* @param desc1 Description of role of first type
* @param type1 First type
@@ -1891,7 +1944,7 @@ public abstract class RelOptUtil {
* @param right filter on the right
* @return AND'd filter
*
- * @see org.eigenbase.rex.RexUtil#composeConjunction
+ * @see org.apache.calcite.rex.RexUtil#composeConjunction
*/
public static RexNode andJoinFilters(
RexBuilder rexBuilder,
@@ -1995,7 +2048,7 @@ public abstract class RelOptUtil {
*
* @deprecated Use the other {@link #classifyFilters};
* 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}.
*/
public static boolean classifyFilters(
RelNode joinRel,
@@ -2059,7 +2112,7 @@ public abstract class RelOptUtil {
final List<RelDataTypeField> rightFields =
joinRel.getInputs().get(1).getRowType().getFieldList();
final int nFieldsRight = rightFields.size();
- assert nTotalFields == (joinRel instanceof SemiJoinRel
+ assert nTotalFields == (joinRel instanceof SemiJoin
? nSysFields + nFieldsLeft
: nSysFields + nFieldsLeft + nFieldsRight);
@@ -2266,14 +2319,14 @@ public abstract class RelOptUtil {
* the input references are the same but the field names are different
*/
public static boolean checkProjAndChildInputs(
- ProjectRelBase project,
+ Project project,
boolean checkNames) {
if (!project.isBoxed()) {
return false;
}
int n = project.getProjects().size();
- RelDataType inputType = project.getChild().getRowType();
+ RelDataType inputType = project.getInput().getRowType();
if (inputType.getFieldList().size() != n) {
return false;
}
@@ -2309,7 +2362,7 @@ public abstract class RelOptUtil {
*
* @param newJoin the RelNode corresponding to the join with its inputs
* swapped
- * @param origJoin original JoinRel
+ * @param origJoin original LogicalJoin
* @param origOrder if true, create the projection expressions to reflect
* the original (pre-swapped) join projection; otherwise,
* create the projection to reflect the order of the swapped
@@ -2318,7 +2371,7 @@ public abstract class RelOptUtil {
*/
public static List<RexNode> createSwappedJoinExprs(
RelNode newJoin,
- JoinRelBase origJoin,
+ Join origJoin,
boolean origOrder) {
final List<RelDataTypeField> newJoinFields =
newJoin.getRowType().getFieldList();
@@ -2338,7 +2391,7 @@ public abstract class RelOptUtil {
/**
* Converts a filter to the new filter that would result if the filter is
- * pushed past a ProjectRel that it currently is referencing.
+ * pushed past a LogicalProject that it currently is referencing.
*
* @param filter the filter to be converted
* @param projRel project rel underneath the filter
@@ -2346,14 +2399,14 @@ public abstract class RelOptUtil {
*/
public static RexNode pushFilterPastProject(
RexNode filter,
- ProjectRelBase projRel) {
- // use RexPrograms to merge the filter and ProjectRel into a
- // single program so we can convert the FilterRel condition to
- // directly reference the ProjectRel's child
+ Project projRel) {
+ // use RexPrograms to merge the filter and LogicalProject into a
+ // single program so we can convert the LogicalFilter condition to
+ // directly reference the LogicalProject's child
RexBuilder rexBuilder = projRel.getCluster().getRexBuilder();
RexProgram bottomProgram =
RexProgram.create(
- projRel.getChild().getRowType(),
+ projRel.getInput().getRowType(),
projRel.getProjects(),
null,
projRel.getRowType(),
@@ -2378,19 +2431,21 @@ public abstract class RelOptUtil {
}
/**
- * Creates a new {@link MultiJoinRel} to reflect projection references from
- * a {@link ProjectRel} that is on top of the {@link MultiJoinRel}.
- *
- * @param multiJoin the original MultiJoinRel
- * @param project the ProjectRel on top of the MultiJoinRel
- * @return the new MultiJoinRel
+ * Creates a new {@link org.apache.calcite.rel.rules.MultiJoin} to reflect
+ * projection references from a
+ * {@link org.apache.calcite.rel.logical.LogicalProject} that is on top of the
+ * {@link org.apache.calcite.rel.rules.MultiJoin}.
+ *
+ * @param multiJoin the original MultiJoin
+ * @param project the LogicalProject on top of the MultiJoin
+ * @return the new MultiJoin
*/
- public static MultiJoinRel projectMultiJoin(
- MultiJoinRel multiJoin,
- ProjectRel project) {
+ public static MultiJoin projectMultiJoin(
+ MultiJoin multiJoin,
+ LogicalProject project) {
// Locate all input references in the projection expressions as well
// the post-join filter. Since the filter effectively sits in
- // between the ProjectRel and the MultiJoinRel, the projection needs
+ // between the LogicalProject and the MultiJoin, the projection needs
// to include those filter references.
BitSet inputRefs = InputFinder.bits(
project.getProjects(), multiJoin.getPostJoinFilter());
@@ -2418,9 +2473,9 @@ public abstract class RelOptUtil {
newProjFields.get(currInput).set(bit - startField);
}
- // create a new MultiJoinRel containing the new field bitmaps
+ // create a new MultiJoin containing the new field bitmaps
// for each input
- return new MultiJoinRel(
+ return new MultiJoin(
multiJoin.getCluster(),
multiJoin.getInputs(),
multiJoin.getJoinFilter(),
@@ -2456,10 +2511,10 @@ public abstract class RelOptUtil {
}
/**
- * Creates a {@link org.eigenbase.rel.ProjectRel} that projects particular
- * fields of its input, according to a mapping.
+ * Creates a {@link org.apache.calcite.rel.logical.LogicalProject} that
+ * projects particular fields of its input, according to a mapping.
*/
- public static ProjectRel project(
+ public static LogicalProject project(
RelNode child,
Mappings.TargetMapping mapping) {
List<RexNode> nodes = new ArrayList<RexNode>();
@@ -2471,8 +2526,8 @@ public abstract class RelOptUtil {
nodes.add(new RexInputRef(source, field.getType()));
names.add(field.getName());
}
- return new ProjectRel(
- child.getCluster(), child, nodes, names, ProjectRel.Flags.BOXED);
+ return new LogicalProject(
+ child.getCluster(), child, nodes, names, LogicalProject.Flags.BOXED);
}
/** Returns whether relational expression {@code target} occurs within a
@@ -2532,7 +2587,8 @@ public abstract class RelOptUtil {
return query;
}
- /** Returns a simple {@link org.eigenbase.relopt.RelOptTable.ToRelContext}. */
+ /** Returns a simple
+ * {@link org.apache.calcite.plan.RelOptTable.ToRelContext}. */
public static RelOptTable.ToRelContext getContext(
final RelOptCluster cluster) {
return new RelOptTable.ToRelContext() {
@@ -2549,7 +2605,7 @@ public abstract class RelOptUtil {
};
}
- /** Returns the number of {@link org.eigenbase.rel.JoinRelBase} nodes in a
+ /** Returns the number of {@link org.apache.calcite.rel.core.Join} nodes in a
* tree. */
public static int countJoins(RelNode rootRel) {
/** Visitor that counts join nodes. */
@@ -2557,7 +2613,7 @@ public abstract class RelOptUtil {
int joinCount;
@Override public void visit(RelNode node, int ordinal, RelNode parent) {
- if (node instanceof JoinRelBase) {
+ if (node instanceof Join) {
++joinCount;
}
super.visit(node, ordinal, parent);
@@ -2629,10 +2685,11 @@ public abstract class RelOptUtil {
* Creates a relational expression which projects an array of expressions,
* and optionally optimizes.
*
- * <p>The result may not be a {@link org.eigenbase.rel.ProjectRel}. If the
+ * <p>The result may not be a
+ * {@link org.apache.calcite.rel.logical.LogicalProject}. If the
* projection is trivial, <code>child</code> is returned directly; and future
* versions may return other formulations of expressions, such as
- * {@link org.eigenbase.rel.CalcRel}.
+ * {@link org.apache.calcite.rel.logical.LogicalCalc}.
*
* @param child input relational expression
* @param exprs list of expressions for the input columns
@@ -2661,18 +2718,17 @@ public abstract class RelOptUtil {
: SqlValidatorUtil.uniquify(
fieldNames, SqlValidatorUtil.F_SUGGESTER));
if (optimize
- && RemoveTrivialProjectRule.isIdentity(exprs, rowType,
- child.getRowType())) {
+ && ProjectRemoveRule.isIdentity(exprs, rowType, child.getRowType())) {
return child;
}
- return new ProjectRel(cluster,
+ return new LogicalProject(cluster,
cluster.traitSetOf(collationList.isEmpty()
? RelCollationImpl.EMPTY
: collationList.get(0)),
child,
exprs,
rowType,
- ProjectRelBase.Flags.BOXED);
+ Project.Flags.BOXED);
}
/**
@@ -2708,9 +2764,10 @@ public abstract class RelOptUtil {
* <p>Optimizations:</p>
*
* <ul>
- * <li>If the relational expression is a {@link org.eigenbase.rel.CalcRel} or
- * {@link org.eigenbase.rel.ProjectRel} that is already acting as a
- * permutation, combines the new permutation with the old;</li>
+ * <li>If the relational expression is a
+ * {@link org.apache.calcite.rel.logical.LogicalCalc} or
+ * {@link org.apache.calcite.rel.logical.LogicalProject} that is already
+ * acting as a permutation, combines the new permutation with the old;</li>
*
* <li>If the permutation is the identity, returns the original relational
* expression.</li>
@@ -2732,16 +2789,16 @@ public abstract class RelOptUtil {
if (permutation.isIdentity()) {
return rel;
}
- if (rel instanceof CalcRel) {
- CalcRel calcRel = (CalcRel) rel;
- Permutation permutation1 = calcRel.getProgram().getPermutation();
+ if (rel instanceof LogicalCalc) {
+ LogicalCalc calc = (LogicalCalc) rel;
+ Permutation permutation1 = calc.getProgram().getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
}
}
- if (rel instanceof ProjectRel) {
- Permutation permutation1 = ((ProjectRel) rel).getPermutation();
+ if (rel instanceof LogicalProject) {
+ Permutation permutation1 = ((LogicalProject) rel).getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
@@ -2780,7 +2837,7 @@ public abstract class RelOptUtil {
rel.getCluster().getTypeFactory().createStructType(
outputTypeList,
outputNameList));
- return new CalcRel(
+ return new LogicalCalc(
rel.getCluster(),
rel.getTraitSet(),
rel,
@@ -2836,13 +2893,13 @@ public abstract class RelOptUtil {
* does not at present.
*
* @param rel Relational expression
- * @param mapping Mapping from source fields to target fields. The mapping
- * type must obey the constraints
- * {@link org.eigenbase.util.mapping.MappingType#isMandatorySource()}
- * and
- * {@link org.eigenbase.util.mapping.MappingType#isSingleSource()},
- * as does
- * {@link org.eigenbase.util.mapping.MappingType#INVERSE_FUNCTION}.
+ * @param mapping Mapping from source fields to target fields. The mapping
+ * type must obey the constraints
+ * {@link org.apache.calcite.util.mapping.MappingType#isMandatorySource()}
+ * and
+ * {@link org.apache.calcite.util.mapping.MappingType#isSingleSource()},
+ * as does
+ * {@link org.apache.calcite.util.mapping.MappingType#INVERSE_FUNCTION}.
* @param fieldNames Field names; if null, or if a particular entry is null,
* the name of the permuted field is used
* @return relational expression which projects a subset of the input fields
@@ -3056,8 +3113,7 @@ public abstract class RelOptUtil {
return null;
}
- @Override
- public Void visitCall(RexCall call) {
+ @Override public Void visitCall(RexCall call) {
if (call.getOperator() == RexBuilder.GET_OPERATOR) {
RexLiteral literal = (RexLiteral) call.getOperands().get(1);
extraFields.add(
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelTrait.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelTrait.java b/core/src/main/java/org/apache/calcite/plan/RelTrait.java
index 4baf877..a3c3efe 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelTrait.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelTrait.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
/**
* RelTrait represents the manifestation of a relational expression trait within
@@ -27,9 +27,9 @@ package org.eigenbase.relopt;
* an {@code enum} and no new RelTraits can be introduced at runtime, you need
* not override {@link #hashCode()} and {@link #equals(Object)}. If, however,
* new RelTrait instances are generated at runtime (e.g. based on state external
- * to the planner), you must implement {@link #hashCode()} and {@link
- * #equals(Object)} for proper {@link RelTraitDef#canonize canonization} of your
- * RelTrait objects.</p>
+ * to the planner), you must implement {@link #hashCode()} and
+ * {@link #equals(Object)} for proper {@link RelTraitDef#canonize canonization}
+ * of your RelTrait objects.</p>
*/
public interface RelTrait {
//~ Methods ----------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java b/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java
index f26bcc0..0273568 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java
@@ -14,12 +14,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import org.eigenbase.rel.*;
-import org.eigenbase.rel.convert.*;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.convert.ConverterRule;
-import com.google.common.cache.*;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
/**
* RelTraitDef represents a class of {@link RelTrait}s. Implementations of
@@ -33,9 +35,10 @@ import com.google.common.cache.*;
* <li>Either
*
* <ul>
- * <li> {@link #canConvert(RelOptPlanner, RelTrait, RelTrait)} and {@link
- * #convert(RelOptPlanner, RelNode, RelTrait, boolean)} do not require
+ * <li> {@link #canConvert(RelOptPlanner, RelTrait, RelTrait)} and
+ * {@link #convert(RelOptPlanner, RelNode, RelTrait, boolean)} do not require
* planner-instance-specific information, <b>or</b></li>
+ *
* <li>the RelTraitDef manages separate sets of conversion data internally. See
* {@link ConventionTraitDef} for an example of this.</li>
* </ul>
@@ -55,8 +58,7 @@ public abstract class RelTraitDef<T extends RelTrait> {
.softValues()
.build(
new CacheLoader<T, T>() {
- @Override
- public T load(T key) throws Exception {
+ @Override public T load(T key) throws Exception {
return key;
}
});
@@ -85,7 +87,7 @@ public abstract class RelTraitDef<T extends RelTrait> {
/**
* @return a simple name for this RelTraitDef (for use in
- * {@link org.eigenbase.rel.RelNode#explain(RelWriter)}).
+ * {@link org.apache.calcite.rel.RelNode#explain}).
*/
public abstract String getSimpleName();
@@ -140,9 +142,9 @@ public abstract class RelTraitDef<T extends RelTrait> {
T toTrait);
/**
- * Provides notification of the registration of a particular {@link
- * ConverterRule} with a {@link RelOptPlanner}. The default implementation
- * does nothing.
+ * Provides notification of the registration of a particular
+ * {@link ConverterRule} with a {@link RelOptPlanner}. The default
+ * implementation does nothing.
*
* @param planner the planner registering the rule
* @param converterRule the registered converter rule
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelTraitPropagationVisitor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitPropagationVisitor.java b/core/src/main/java/org/apache/calcite/plan/RelTraitPropagationVisitor.java
index ec6b24f..486fecc 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelTraitPropagationVisitor.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelTraitPropagationVisitor.java
@@ -14,10 +14,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import org.eigenbase.rel.*;
-import org.eigenbase.util.Util;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelVisitor;
+import org.apache.calcite.util.Util;
/**
* RelTraitPropagationVisitor traverses a RelNode and its <i>unregistered</i>
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
index ecd2ec0..33072d1 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
@@ -14,16 +14,19 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
-import java.util.*;
-
-import org.eigenbase.util.Pair;
-
-import net.hydromatic.optiq.runtime.FlatLists;
+import org.apache.calcite.runtime.FlatLists;
+import org.apache.calcite.util.Pair;
import com.google.common.collect.ImmutableList;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
/**
* RelTraitSet represents an ordered set of {@link RelTrait}s.
*/
@@ -173,15 +176,13 @@ public final class RelTraitSet extends AbstractList<RelTrait> {
* @param obj another RelTraitSet
* @return true if traits are equal and in the same order, false otherwise
*/
- @Override
- public boolean equals(Object obj) {
+ @Override public boolean equals(Object obj) {
return this == obj
|| obj instanceof RelTraitSet
&& Arrays.equals(traits, ((RelTraitSet) obj).traits);
}
- @Override
- public int hashCode() {
+ @Override public int hashCode() {
return Arrays.hashCode(traits);
}
@@ -284,8 +285,7 @@ public final class RelTraitSet extends AbstractList<RelTrait> {
return Arrays.equals(traits, relTraits);
}
- @Override
- public String toString() {
+ @Override public String toString() {
return string;
}
http://git-wip-us.apache.org/repos/asf/incubator-calcite/blob/a0ba73cd/core/src/main/java/org/apache/calcite/plan/Strong.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/plan/Strong.java b/core/src/main/java/org/apache/calcite/plan/Strong.java
index 4415757..e279b14 100644
--- a/core/src/main/java/org/apache/calcite/plan/Strong.java
+++ b/core/src/main/java/org/apache/calcite/plan/Strong.java
@@ -14,16 +14,16 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.eigenbase.relopt;
+package org.apache.calcite.plan;
+
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
import java.util.BitSet;
import java.util.List;
-import org.eigenbase.rex.RexCall;
-import org.eigenbase.rex.RexInputRef;
-import org.eigenbase.rex.RexLiteral;
-import org.eigenbase.rex.RexNode;
-
/** Utilities for strong predicates.
*
* <p>A predicate is strong (or null-rejecting) if it is UNKNOWN if any of its