Hive优化器原理与源码解析系列--优化规则SortLimitPullUpConstantsRule(七)

final RelNode parent = call.rel(0);//根Root不是SortLimit
    final Sort sort = call.rel(1);
    final int count = sort.getInput().getRowType().getFieldCount(); //sort输入子RelNode Project投影的字段个数
    if (count == 1) {
      return;
    }
    final RexBuilder rexBuilder = sort.getCluster().getRexBuilder();
    final RelMetadataQuery mq = RelMetadataQuery.instance();
    final RelOptPredicateList predicates = mq.getPulledUpPredicates(sort.getInput());
    // 有关保留在从关系表达式RelNode发出的行中的谓词的元数据。
    if (predicates == null) {//如果没有谓词，即where条件，将不做任何优化
      return;
    }
    Map<RexNode, RexNode> conditionsExtracted = HiveReduceExpressionsRule.predicateConstants(
            //A map of each (e, constant) pair that occurs within pulledUpPredicates.
            RexNode.class, rexBuilder, predicates);//再从所有谓词集合中，把常量谓词提取
    Map<RexNode, RexNode> constants = new HashMap<>();
    for (int i = 0; i < count ; i++) { //遍历Project中指定的输入列引用
      RexNode expr = rexBuilder.makeInputRef(sort.getInput(), i);
      if (conditionsExtracted.containsKey(expr)) {
        constants.put(expr, conditionsExtracted.get(expr));//如果sort的输入子RelNode指定字段索引在常量谓词中，则加载constants映射中
      }
    }
    if (constants.isEmpty()) {
      return;
    }

List<RelDataTypeField> fields = sort.getInput().getRowType().getFieldList(); //获取Project中的字段列表
List<Pair<RexNode, String>> newChildExprs = new ArrayList<>(); //存放新的子表达式映射集合
List<RexNode> topChildExprs = new ArrayList<>();
List<String> topChildExprsFields = new ArrayList<>();

for (int i = 0; i < count ; i++) {
  RexNode expr = rexBuilder.makeInputRef(sort.getInput(), i); //创建Project中，指定的字段引用
  RelDataTypeField field = fields.get(i);
  if (constants.containsKey(expr)) {//如果此引用表达式在等值常量谓词映射中
    topChildExprs.add(constants.get(expr));//等值谓词常量表达式，这里存放的常量如a=1中1
    topChildExprsFields.add(field.getName());//等值常量谓词字段名称 a 字段名称  
  } else {
    newChildExprs.add(Pair.of(expr, field.getName())); //
    topChildExprs.add(expr);//如果该字段引用不在等值常量谓词表达式出现的字段，存在存放字段引用，如id
    topChildExprsFields.add(field.getName());
  }
}

// Update field collations 不在常量RexNode映射中的，
    final Mappings.TargetMapping mapping =
            RelOptUtil.permutation(Pair.left(newChildExprs), sort.getInput().getRowType()).inverse();//Project不在谓词常量集合的字段，与Project所有字段的mapping映射关系
//e字段表达式，与所有字段的排列组合,但是inverse 转换为了sort.getInput().getRowType()，Pair.left(newChildExprs)的映射关系
    List<RelFieldCollation> fieldCollations = new ArrayList<>();
    for (RelFieldCollation fc : sort.getCollation().getFieldCollations()) {//排序字段
      final int target = mapping.getTargetOpt(fc.getFieldIndex());//Returns the target that a source maps to, or -1 if it is not mapped.
      if (target < 0) {
        // It is a constant, we can ignore it
        continue;
      }
      fieldCollations.add(fc.copy(target));//找到在Sort中出现的，也必须select中出现的。
    }

// Update top Project positions         select中字段已经更新为常量
topChildExprs = ImmutableList.copyOf(RexUtil.apply(mapping, topChildExprs));//并生成一个新的排序列表

final RelBuilder relBuilder = call.builder();
relBuilder.push(sort.getInput());//压入的Sort的子RelNode，
relBuilder.project(Pair.left(newChildExprs), Pair.right(newChildExprs));//Creates a Project of the given list of expressions and field names.

final ImmutableList<RexNode> sortFields =
          relBuilder.fields(RelCollations.of(fieldCollations));
  relBuilder.sortLimit(sort.offset == null ? -1 : RexLiteral.intValue(sort.offset),
          sort.fetch == null ? -1 : RexLiteral.intValue(sort.fetch), sortFields); // 使用上述整理的Sort排序字段，创建Sort
  // Create top Project fixing nullability of fields
  relBuilder.project(topChildExprs, topChildExprsFields);//创建上拉了常量谓词表达式Project
  relBuilder.convert(sort.getRowType(), false);//创建将当前关系表达式的输出转换为所需行类型的投影Project。
  List<RelNode> inputs = new ArrayList<>();
  for (RelNode child : parent.getInputs()) {  //最外层的RelNode
    if (!((HepRelVertex) child).getCurrentRel().equals(sort)) {//遍历父RelNode的子RelNode，不等于的都加入RelNode list，否则使用relBuilder.build()
      inputs.add(child);
    } else {
      inputs.add(relBuilder.build());//Returns the final relational expression. 如果等于sort对象，就返回最终的RelNode
    }
  }
  call.transformTo(parent.copy(parent.getTraitSet(), inputs));
}