import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
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;
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
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);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
@Override
public RelNode visit(LogicalSort sort) {
  if (isLimit0(sort.fetch)) {
    contains = true;
    return sort;
  }

  return super.visit(sort);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
@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)
  );
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
@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);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
private DrillLimitRule() {
  super(RelOptHelper.any(LogicalSort.class, Convention.NONE), "DrillLimitRule");
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
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)));
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
@Override
public RelNode visit(LogicalSort sort) {
  return visit((RelNode) sort);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
private LimitRule() {
  super(RelOptHelper.any(LogicalSort.class, Convention.NONE), "LimitRule");
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
private BeamSortRule() {
  super(LogicalSort.class, Convention.NONE,
      BeamLogicalConvention.INSTANCE, "BeamSortRule");
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
@Override public RelNode visit(LogicalSort sort) {
  return visit((RelNode) sort);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
public RelNode visit(LogicalSort sort) {
  return visitChildren(sort);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
public RelNode createSort(RelNode input, RelCollation collation,
    RexNode offset, RexNode fetch) {
  return LogicalSort.create(input, collation, offset, fetch);
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
public RelNode visit(LogicalSort sort) {
  return sort;
}
 

import org.apache.calcite.rel.logical.LogicalSort; //导入依赖的package包/类
RelNode visit(LogicalSort sort);