import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param root The root of the plan.
 */
public OrderByInSubQueryRemover(RelNode root)
{
  // Identify if there is either a sort at the plan root, or
  // a Project with a sort at the plan root. These Sorts should not
  // be skipped since ORDER BY is always legal there.
  if (root instanceof Sort) {
    this.topLevelSort = (Sort) root;
  }
  else if (root instanceof Project &&
    root.getInput(0) instanceof Sort) {
    this.topLevelSort = (Sort) root.getInput(0);
  }
  else {
    this.topLevelSort = null;
  }
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
    final Sort sort = call.rel(0);
    if (sort.offset == null && sort.fetch == null) {
        return;
    }

    RelTraitSet origTraitSet = sort.getTraitSet();
    RelTraitSet traitSet = origTraitSet.replace(OLAPRel.CONVENTION).simplify();

    RelNode input = sort.getInput();
    if (!sort.getCollation().getFieldCollations().isEmpty()) {
        // Create a sort with the same sort key, but no offset or fetch.
        input = sort.copy(sort.getTraitSet(), input, sort.getCollation(), null, null);
    }
    RelNode x = convert(input, input.getTraitSet().replace(OLAPRel.CONVENTION));
    call.transformTo(new OLAPLimitRel(sort.getCluster(), traitSet, x, sort.offset, sort.fetch));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
/** Returns a string describing the operations inside this query.
 *
 * <p>For example, "sfpaol" means {@link TableScan} (s)
 * followed by {@link Filter} (f)
 * followed by {@link Project} (p)
 * followed by {@link Aggregate} (a)
 * followed by {@link Project} (o)
 * followed by {@link Sort} (l).
 *
 * @see #isValidSignature(String)
 */
String signature() {
  final StringBuilder b = new StringBuilder();
  boolean flag = false;
  for (RelNode rel : rels) {
    b.append(rel instanceof TableScan ? 's'
        : (rel instanceof Project && flag) ? 'o'
        : rel instanceof Filter ? 'f'
        : rel instanceof Aggregate ? 'a'
        : rel instanceof Sort ? 'l'
        : rel instanceof Project ? 'p'
        : '!');
    flag = flag || rel instanceof Aggregate;
  }
  return b.toString();
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  final Sort sort = call.rel(0);
  final DruidQuery query = call.rel(1);
  if (!DruidQuery.isValidSignature(query.signature() + 'l')) {
    return;
  }
  // Either it is:
  // - a sort and limit on a dimension/metric part of the druid group by query or
  // - a sort without limit on the time column on top of
  //     Agg operator (transformable to timeseries query), or
  // - a simple limit on top of other operator than Agg
  if (!validSortLimit(sort, query)) {
    return;
  }
  final RelNode newSort = sort.copy(sort.getTraitSet(),
          ImmutableList.of(Util.last(query.rels)));
  call.transformTo(DruidQuery.extendQuery(query, newSort));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
public Double getMaxRowCount(Sort rel, RelMetadataQuery mq) {
  Double rowCount = mq.getMaxRowCount(rel.getInput());
  if (rowCount == null) {
    rowCount = Double.POSITIVE_INFINITY;
  }
  final int offset = rel.offset == null ? 0 : RexLiteral.intValue(rel.offset);
  rowCount = Math.max(rowCount - offset, 0D);

  if (rel.fetch != null) {
    final int limit = RexLiteral.intValue(rel.fetch);
    if (limit < rowCount) {
      return (double) limit;
    }
  }
  return rowCount;
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
public Double getMinRowCount(Sort rel, RelMetadataQuery mq) {
  Double rowCount = mq.getMinRowCount(rel.getInput());
  if (rowCount == null) {
    rowCount = 0D;
  }
  final int offset = rel.offset == null ? 0 : RexLiteral.intValue(rel.offset);
  rowCount = Math.max(rowCount - offset, 0D);

  if (rel.fetch != null) {
    final int limit = RexLiteral.intValue(rel.fetch);
    if (limit < rowCount) {
      return (double) limit;
    }
  }
  return rowCount;
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  final Project project = call.rel(0);
  final Sort sort = call.rel(1);
  if (sort.getClass() != Sort.class) {
    return;
  }
  RelNode newProject =
      project.copy(
          project.getTraitSet(), ImmutableList.of(sort.getInput()));
  final Sort newSort =
      sort.copy(
          sort.getTraitSet(),
          newProject,
          sort.getCollation(),
          sort.offset,
          sort.fetch);
  call.transformTo(newSort);
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的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.core.Sort; //导入依赖的package包/类
/** @see #dispatch */
public Result visit(Sort e) {
  Result x = visitChild(0, e.getInput());
  Builder builder = x.builder(e, Clause.ORDER_BY);
  List<SqlNode> orderByList = Expressions.list();
  for (RelFieldCollation field : e.getCollation().getFieldCollations()) {
    builder.addOrderItem(orderByList, field);
  }
  if (!orderByList.isEmpty()) {
    builder.setOrderBy(new SqlNodeList(orderByList, POS));
    x = builder.result();
  }
  if (e.fetch != null) {
    builder = x.builder(e, Clause.FETCH);
    builder.setFetch(builder.context.toSql(null, e.fetch));
    x = builder.result();
  }
  if (e.offset != null) {
    builder = x.builder(e, Clause.OFFSET);
    builder.setOffset(builder.context.toSql(null, e.offset));
    x = builder.result();
  }
  return x;
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的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.core.Sort; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
  final Sort incomingSort = call.rel(0);
  final RelTraitSet incomingTraits = incomingSort.getTraitSet();
  RelNode input = incomingSort.getInput();

  // if the Optiq sort rel includes a collation and a limit, we need to create a copy the sort rel that excludes the
  // limit information.
  if (!incomingSort.getCollation().getFieldCollations().isEmpty()) {
    input = incomingSort.copy(incomingTraits, input, incomingSort.getCollation(), null, null);
  }

  RelNode convertedInput = convert(input, input.getTraitSet().plus(DrillRel.DRILL_LOGICAL));
  call.transformTo(new DrillLimitRel(incomingSort.getCluster(), convertedInput.getTraitSet().plus(DrillRel.DRILL_LOGICAL), convertedInput, incomingSort.offset, incomingSort.fetch));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {

  final Sort sort = call.rel(0);

  final RelNode input = sort.getInput();
  final RelTraitSet traits = sort.getTraitSet().plus(DrillRel.DRILL_LOGICAL);

  final RelNode convertedInput = convert(input, input.getTraitSet().plus(DrillRel.DRILL_LOGICAL));
  call.transformTo(new DrillSortRel(sort.getCluster(), traits, convertedInput, sort.getCollation()));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public RelNode convert(RelNode r) {
  Sort rel = (Sort) r;
  return new SortPrel(rel.getCluster(),
                      rel.getInput().getTraitSet().replace(Prel.DRILL_PHYSICAL).plus(rel.getCollation()),
                      convert(rel.getInput(), rel.getInput().getTraitSet().replace(Prel.DRILL_PHYSICAL)),
                      rel.getCollation());
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {

  final Sort sort = call.rel(0);

  final RelNode input = sort.getInput();
  final RelTraitSet traits = sort.getTraitSet().plus(Rel.LOGICAL);

  final RelNode convertedInput = convert(input, input.getTraitSet().plus(Rel.LOGICAL).simplify());
  call.transformTo(new SortRel(sort.getCluster(), traits, convertedInput, sort.getCollation()));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
  final Sort incomingSort = call.rel(0);
  final RelTraitSet incomingTraits = incomingSort.getTraitSet();
  RelNode input = incomingSort.getInput();

  // if the calcite sort rel includes a collation and a limit, we need to create a copy the sort rel that excludes the
  // limit information.
  if (!incomingSort.getCollation().getFieldCollations().isEmpty()) {
    input = incomingSort.copy(incomingTraits, input, incomingSort.getCollation(), null, null);
  }

  RelNode convertedInput = convert(input, input.getTraitSet().plus(Rel.LOGICAL).simplify());
  call.transformTo(new LimitRel(incomingSort.getCluster(), convertedInput.getTraitSet().plus(Rel.LOGICAL), convertedInput, incomingSort.offset, incomingSort.fetch));
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
public RelNode convert(RelNode r) {
  Sort rel = (Sort) r;
  return new SortPrel(rel.getCluster(),
                      rel.getInput().getTraitSet().replace(Prel.PHYSICAL).plus(rel.getCollation()),
                      convert(rel.getInput(), rel.getInput().getTraitSet().replace(Prel.PHYSICAL).simplify()),
                      rel.getCollation());
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override
protected RelNode visitChild(RelNode parent, int i, RelNode child) {

  // Ignore the root node.
  if (null == parent) {
    return super.visitChild(parent, i, child);
  }

  // Ignore non-sort child nodes.
  if (!(child instanceof Sort)) {
    return super.visitChild(parent, i, child);
  }

  // Ignore the sort for the top level SELECT. It's valid to use ORDER BY
  // without FETCH / OFFSET here.
  if (child == topLevelSort) {
    return super.visitChild(parent, i, child);
  }

  // If the child Sort has FETCH and LIMIT clauses, do not touch them.
  Sort childAsSort = (Sort) child;
  if (childAsSort.offset == null &&
      childAsSort.fetch == null) {
    parent.replaceInput(i, childAsSort.getInput());
    return super.visitChild(parent, i, childAsSort.getInput());
  }

  return super.visitChild(parent, i, child);
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
@Override public RelNode convert(RelNode rel) {
  Sort sort = (Sort) rel;
  final RelNode input = sort.getInput();
  return new BeamSortRel(
      sort.getCluster(),
      sort.getTraitSet().replace(BeamLogicalConvention.INSTANCE),
      convert(input, input.getTraitSet().replace(BeamLogicalConvention.INSTANCE)),
      sort.getCollation(),
      sort.offset,
      sort.fetch
  );
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
private RelCollation requiredCollation(RelNode r) {
	if (r instanceof Sort) {
		return ((Sort) r).collation;
	}
	if (r instanceof Project) {
		return requiredCollation(((Project) r).getInput());
	}
	if (r instanceof Delta) {
		return requiredCollation(((Delta) r).getInput());
	}
	throw new AssertionError();
}
 

import org.apache.calcite.rel.core.Sort; //导入依赖的package包/类
/**
 * Rewrite Sort.
 *
 * @param rel Sort to be rewritten
 */
public Frame decorrelateRel(Sort rel) {
	//
	// Rewrite logic:
	//
	// 1. change the collations field to reference the new input.
	//

	// Sort itself should not reference cor vars.
	assert !cm.mapRefRelToCorVar.containsKey(rel);

	// Sort only references field positions in collations field.
	// The collations field in the newRel now need to refer to the
	// new output positions in its input.
	// Its output does not change the input ordering, so there's no
	// need to call propagateExpr.

	final RelNode oldInput = rel.getInput();
	final Frame frame = getInvoke(oldInput, rel);
	if (frame == null) {
		// If input has not been rewritten, do not rewrite this rel.
		return null;
	}
	final RelNode newInput = frame.r;

	Mappings.TargetMapping mapping = Mappings.target(frame.oldToNewOutputPos, oldInput.getRowType().getFieldCount(), newInput.getRowType().getFieldCount());

	RelCollation oldCollation = rel.getCollation();
	RelCollation newCollation = RexUtil.apply(mapping, oldCollation);

	final Sort newSort = LogicalSort.create(newInput, newCollation, rel.offset, rel.fetch);

	// Sort does not change input ordering
	return register(rel, newSort, frame.oldToNewOutputPos, frame.corVarOutputPos);
}