org.apache.calcite.rel.logical.LogicalSort Java Examples

public void rewriteRel(Sort rel) {
  RelCollation oldCollation = rel.getCollation();
  final RelNode oldChild = rel.getInput();
  final RelNode newChild = getNewForOldRel(oldChild);
  final Mappings.TargetMapping mapping =
      getNewForOldInputMapping(oldChild);

  // validate
  for (RelFieldCollation field : oldCollation.getFieldCollations()) {
    int oldInput = field.getFieldIndex();
    RelDataType sortFieldType =
        oldChild.getRowType().getFieldList().get(oldInput).getType();
    if (sortFieldType.isStruct()) {
      // TODO jvs 10-Feb-2005
      throw Util.needToImplement("sorting on structured types");
    }
  }
  RelCollation newCollation = RexUtil.apply(mapping, oldCollation);
  Sort newRel =
      LogicalSort.create(newChild, newCollation, rel.offset, rel.fetch);
  setNewForOldRel(rel, newRel);
}
 

public RelNode convert(
    RelOptPlanner planner,
    RelNode rel,
    RelCollation toCollation,
    boolean allowInfiniteCostConverters) {
  if (toCollation.getFieldCollations().isEmpty()) {
    // An empty sort doesn't make sense.
    return null;
  }

  // Create a logical sort, then ask the planner to convert its remaining
  // traits (e.g. convert it to an EnumerableSortRel if rel is enumerable
  // convention)
  final Sort sort = LogicalSort.create(rel, toCollation, null, null);
  RelNode newRel = planner.register(sort, rel);
  final RelTraitSet newTraitSet = rel.getTraitSet().replace(toCollation);
  if (!newRel.getTraitSet().equals(newTraitSet)) {
    newRel = planner.changeTraits(newRel, newTraitSet);
  }
  return newRel;
}
 

public RelNode convert(
    RelOptPlanner planner,
    RelNode rel,
    RelCollation toCollation,
    boolean allowInfiniteCostConverters) {
  if (toCollation.getFieldCollations().isEmpty()) {
    // An empty sort doesn't make sense.
    return null;
  }

  // Create a logical sort, then ask the planner to convert its remaining
  // traits (e.g. convert it to an EnumerableSortRel if rel is enumerable
  // convention)
  final Sort sort = LogicalSort.create(rel, toCollation, null, null);
  RelNode newRel = planner.register(sort, rel);
  final RelTraitSet newTraitSet = rel.getTraitSet().replace(toCollation);
  if (!newRel.getTraitSet().equals(newTraitSet)) {
    newRel = planner.changeTraits(newRel, newTraitSet);
  }
  return newRel;
}
 

public void rewriteRel(Sort rel) {
    RelCollation oldCollation = rel.getCollation();
    final RelNode oldChild = rel.getInput();
    final RelNode newChild = getNewForOldRel(oldChild);
    final Mappings.TargetMapping mapping = getNewForOldInputMapping(oldChild);

    // validate
    for (RelFieldCollation field : oldCollation.getFieldCollations()) {
        int oldInput = field.getFieldIndex();
        RelDataType sortFieldType = oldChild.getRowType().getFieldList().get(oldInput).getType();
        if (sortFieldType.isStruct()) {
            // TODO jvs 10-Feb-2005
            throw Util.needToImplement("sorting on structured types");
        }
    }
    RelCollation newCollation = RexUtil.apply(mapping, oldCollation);
    Sort newRel = LogicalSort.create(newChild, newCollation, rel.offset, rel.fetch);
    setNewForOldRel(rel, newRel);
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Delta delta = call.rel(0);
  Util.discard(delta);
  final Sort sort = call.rel(1);
  final LogicalDelta newDelta =
      LogicalDelta.create(sort.getInput());
  final LogicalSort newSort =
      LogicalSort.create(newDelta, sort.collation, sort.offset, sort.fetch);
  call.transformTo(newSort);
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Delta delta = call.rel(0);
  Util.discard(delta);
  final Sort sort = call.rel(1);
  final LogicalDelta newDelta =
      LogicalDelta.create(sort.getInput());
  final LogicalSort newSort =
      LogicalSort.create(newDelta, sort.collation, sort.offset, sort.fetch);
  call.transformTo(newSort);
}
 

@Override
public RelNode visit(LogicalSort sort) {
  final RelNode input = sort.getInput().accept(this);
  return new LogicalSort(
    cluster,
    copyOf(sort.getTraitSet()),
    input,
    sort.getCollation(),
    copyOf(sort.offset),
    copyOf(sort.fetch)
  );
}
 

public RelNode convert(RelNode relNode) {
    final LogicalSort sort = (LogicalSort) relNode;
    final RelTraitSet traitSet = sort.getTraitSet().replace(getOutTrait()).replace(sort.getCollation());
    return new ElasticsearchSort(relNode.getCluster(), traitSet,
            convert(sort.getInput(), traitSet.replace(RelCollations.EMPTY)), sort.getCollation(),
            sort.offset, sort.fetch);
}
 

public RelNode convert(RelNode relNode) {
    final LogicalSort sort = (LogicalSort) relNode;
    final RelTraitSet traitSet = sort.getTraitSet().replace(getOutTrait()).replace(sort.getCollation());
    return new ElasticsearchSort(relNode.getCluster(), traitSet,
            convert(sort.getInput(), traitSet.replace(RelCollations.EMPTY)), sort.getCollation(),
            sort.offset, sort.fetch);
}
 

@Override
public RelNode visit(LogicalSort sort) {
  if (DrillRelOptUtil.isLimit0(sort.fetch)) {
    contains = true;
    return sort;
  }

  return super.visit(sort);
}
 

private LimitRule() {
  super(RelOptHelper.any(LogicalSort.class, Convention.NONE), "LimitRule");
}
 

/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-3183">[CALCITE-3183]
 * Trimming method for Filter rel uses wrong traitSet</a>. */
@Test void testFilterAndSortWithTrim() {
  // Create a customized test with RelCollation trait in the test cluster.
  Tester tester = new TesterImpl(getDiffRepos(),
      false, true,
      true, false, true,
      null, null) {
    @Override public RelOptPlanner createPlanner() {
      return new MockRelOptPlanner(Contexts.empty()) {
        @Override public List<RelTraitDef> getRelTraitDefs() {
          return ImmutableList.<RelTraitDef>of(RelCollationTraitDef.INSTANCE);
        }
        @Override public RelTraitSet emptyTraitSet() {
          return RelTraitSet.createEmpty().plus(
              RelCollationTraitDef.INSTANCE.getDefault());
        }
      };
    }
  };

  // Run query and save plan after trimming
  final String sql = "select count(a.EMPNO)\n"
      + "from (select * from emp order by sal limit 3) a\n"
      + "where a.EMPNO > 10 group by 2";
  RelNode afterTrim = tester.convertSqlToRel(sql).rel;

  // Get Sort and Filter operators
  final List<RelNode> rels = new ArrayList<>();
  final RelShuttleImpl visitor = new RelShuttleImpl() {
    @Override public RelNode visit(LogicalSort sort) {
      rels.add(sort);
      return super.visit(sort);
    }
    @Override public RelNode visit(LogicalFilter filter) {
      rels.add(filter);
      return super.visit(filter);
    }
  };
  visitor.visit(afterTrim);

  // Ensure sort and filter operators have consistent traitSet after trimming
  assertThat(rels.size(), is(2));
  RelTrait filterCollation = rels.get(0).getTraitSet()
      .getTrait(RelCollationTraitDef.INSTANCE);
  RelTrait sortCollation = rels.get(1).getTraitSet()
      .getTrait(RelCollationTraitDef.INSTANCE);
  assertTrue(filterCollation.satisfies(sortCollation));
}
 

public RelNode visit(LogicalSort sort) {
  return sort;
}
 

public RelNode createSort(RelNode input, RelCollation collation,
    RexNode offset, RexNode fetch) {
  return LogicalSort.create(input, collation, offset, fetch);
}
 

@Override public RelNode visit(LogicalSort sort) {
  return visit((RelNode) sort);
}
 

public RelNode visit(LogicalSort sort) {
  return visitChildren(sort);
}
 

@Override public RelNode visit(LogicalSort sort) {
  return visit((RelNode) sort);
}
 

public RelNode visit(LogicalSort sort) {
  return visitChildren(sort);
}
 

private SortRule() {
  super(RelOptHelper.any(LogicalSort.class, Convention.NONE), "SortRule");
}
 

@Override
public RelNode visit(LogicalSort sort) {
  return visit((RelNode) sort);
}
 

public RelNode createSort(RelNode input, RelCollation collation,
    RexNode offset, RexNode fetch) {
  return LogicalSort.create(input, collation, offset, fetch);
}
 

private DrillLimitRule() {
  super(RelOptHelper.any(LogicalSort.class, Convention.NONE),
      DrillRelFactories.LOGICAL_BUILDER, "DrillLimitRule");
}
 

ElasticsearchSortRule(){
    super(LogicalSort.class, Convention.NONE, ElasticsearchRelNode.CONVENTION,
            ElasticsearchSortRule.class.getSimpleName());
}
 

private static RelNode createEmptyEmptyRelHelper(SingleRel input) {
  return LogicalSort.create(input.getInput(), RelCollations.EMPTY,
      input.getCluster().getRexBuilder().makeExactLiteral(BigDecimal.valueOf(0)),
      input.getCluster().getRexBuilder().makeExactLiteral(BigDecimal.valueOf(0)));
}
 

ElasticsearchSortRule(){
    super(LogicalSort.class, Convention.NONE, ElasticsearchRelNode.CONVENTION,
            ElasticsearchSortRule.class.getSimpleName());
}
 

@Override
public RelNode visit(LogicalSort sort) {
  return sort;
}
 

RelNode visit(LogicalSort sort); 

RelNode visit(LogicalSort sort);