Examples of org.eigenbase.rel.RelNode

org.eigenbase.rel.RelNode
A RelNode is a relational expression.
A relational expression is not a scalar expression; see {@link org.eigenbase.sql.SqlNode} and {@link RexNode}.

If this type of relational expression has some particular planner rules, it should implement the public static method {@link AbstractRelNode#register}.

When a relational expression comes to be implemented, the system allocates a {@link org.eigenbase.relopt.RelImplementor} to manage the process. Everyimplementable relational expression has a {@link RelTraitSet} describing itsphysical attributes. The RelTraitSet always contains a {@link Convention}describing how the expression passes data to its consuming relational expression, but may contain other traits, including some applied externally. Because traits can be applied externally, implementations of RelNode should never assume the size or contents of their trait set (beyond those traits configured by the RelNode itself).

For each calling-convention, there is a corresponding sub-interface of RelNode. For example, {@code net.hydromatic.optiq.rules.java.EnumerableRel}has operations to manage the conversion to a graph of {@code net.hydromatic.optiq.rules.java.EnumerableConvention}calling-convention, and it interacts with a {@code EnumerableRelImplementor}.

A relational expression is only required to implement its calling-convention's interface when it is actually implemented, that is, converted into a plan/program. This means that relational expressions which cannot be implemented, such as converters, are not required to implement their convention's interface.

Every relational expression must derive from {@link AbstractRelNode}. (Why have the RelNode interface, then? We need a root interface, because an interface can only derive from an interface.)

    return instance;
  }


  public RelNode flattenTypes(RelOptPlanner planner, RelNode rootRel,
      boolean restructure) {
    RelNode root2 =
        planner.changeTraits(rootRel,
            rootRel.getTraitSet().plus(SparkRel.CONVENTION));
    return planner.changeTraits(root2, rootRel.getTraitSet());
  }

View Full Code Here

  public static Program standard() {
    final Program program1 =
        new Program() {
          public RelNode run(RelOptPlanner planner, RelNode rel,
              RelTraitSet requiredOutputTraits) {
            final RelNode rootRel2 =
                planner.changeTraits(rel, requiredOutputTraits);
            assert rootRel2 != null;


            planner.setRoot(rootRel2);
            final RelOptPlanner planner2 = planner.chooseDelegate();
            final RelNode rootRel3 = planner2.findBestExp();
            assert rootRel3 != null : "could not implement exp";
            return rootRel3;
          }
        };

View Full Code Here

   * </pre>
   *
   * </ol>
   */
  public RelOptPredicateList getPredicates(ProjectRelBase project) {
    RelNode child = project.getChild();
    RelOptPredicateList childInfo =
        RelMetadataQuery.getPulledUpPredicates(child);


    List<RexNode> projectPullUpPredicates = new ArrayList<RexNode>();


    BitSet columnsMapped = new BitSet(child.getRowType().getFieldCount());
    Mapping m = Mappings.create(MappingType.PARTIAL_FUNCTION,
        child.getRowType().getFieldCount(),
        project.getRowType().getFieldCount());


    for (Ord<RexNode> o : Ord.zip(project.getProjects())) {
      if (o.e instanceof RexInputRef) {
        int sIdx = ((RexInputRef) o.e).getIndex();

View Full Code Here


  /**
   * Add the Filter condition to the pulledPredicates list from the child.
   */
  public RelOptPredicateList getPredicates(FilterRelBase filter) {
    RelNode child = filter.getChild();
    RelOptPredicateList childInfo =
        RelMetadataQuery.getPulledUpPredicates(child);


    return RelOptPredicateList.of(
        Iterables.concat(childInfo.pulledUpPredicates,

View Full Code Here

            RelOptUtil.conjunctions(filter.getCondition())));
  }


  public RelOptPredicateList getPredicates(JoinRelBase join) {
    RexBuilder rB = join.getCluster().getRexBuilder();
    RelNode left = join.getInput(0);
    RelNode right = join.getInput(1);


    RelOptPredicateList leftInfo =
        RelMetadataQuery.getPulledUpPredicates(left);
    RelOptPredicateList rightInfo =
        RelMetadataQuery.getPulledUpPredicates(right);

View Full Code Here

   * groupSet         : { a, b}
   * pulledUpExprs    : { a > 7}
   * </pre>
   */
  public RelOptPredicateList getPredicates(AggregateRelBase agg) {
    RelNode child = agg.getChild();
    RelOptPredicateList childInfo =
        RelMetadataQuery.getPulledUpPredicates(child);


    List<RexNode> aggPullUpPredicates = new ArrayList<RexNode>();


    BitSet groupKeys = agg.getGroupSet();
    Mapping m = Mappings.create(MappingType.PARTIAL_FUNCTION,
        child.getRowType().getFieldCount(), agg.getRowType().getFieldCount());


    int i = 0;
    for (int j : BitSets.toIter(groupKeys)) {
      m.set(j, i++);
    }

View Full Code Here


  /**
   * Infers predicates for a SortRel.
   */
  public RelOptPredicateList getPredicates(SortRel sort) {
    RelNode child = sort.getInput(0);
    return RelMetadataQuery.getPulledUpPredicates(child);
  }

View Full Code Here

  }


  @Override
  public void onMatch(RelOptRuleCall call) {
    final ProjectRel project = (ProjectRel) call.rel(0);
    final RelNode input = call.rel(1);
    final RelTraitSet traits = project.getTraitSet().plus(DrillRel.CONVENTION);
    final RelNode convertedInput = convert(input, traits);
    call.transformTo(new DrillProjectRel(project.getCluster(), traits, convertedInput, project.getProjects(), project
        .getRowType()));
  }

View Full Code Here

  }


  @Override
  public void onMatch(RelOptRuleCall call) {
    final SortRel sort = call.rel(0);
    final RelNode input = call.rel(1);
    final RelTraitSet traits = sort.getTraitSet().plus(DrillRel.CONVENTION);
    final RelTraitSet inputTraits = input.getTraitSet().plus(DrillRel.CONVENTION);
    final RelNode convertedInput = convert(input, inputTraits);
    call.transformTo(new DrillSortRel(sort.getCluster(), traits, convertedInput, sort.getCollation()));
  }

View Full Code Here

  }


  @Override
  public void onMatch(RelOptRuleCall call) {
    final FilterRel filter = (FilterRel) call.getRels()[0];
    final RelNode input = call.getRels()[1];
    final RelTraitSet traits = filter.getTraitSet().plus(DrillRel.CONVENTION);
    final RelNode convertedInput = convert(input, traits);
    call.transformTo(new DrillFilterRel(filter.getCluster(), traits, convertedInput, filter.getCondition()));
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eigenbase.rel.RelNode

cascading.lingual.optiq.CascadingAggregateConverterRule

cascading.lingual.optiq.CascadingAggregateRel

cascading.lingual.optiq.CascadingCalcConverterRule

cascading.lingual.optiq.CascadingJoinRule

cascading.lingual.optiq.CascadingProjectConverterRule

cascading.lingual.optiq.CascadingSortRel

cascading.lingual.optiq.CascadingTableModificationConverterRule

cascading.lingual.tap.TapTable

net.hydromatic.optiq.impl.spark.SparkHandlerImpl

net.hydromatic.optiq.impl.ViewTable

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.