Hive优化器原理与源码解析系列--优化规则HiveJoinAddNotNullRule(十二)

public boolean matches(RelOptRuleCall call) {
  return true;
}

private static List<RexNode> getNotNullConditions(RelOptCluster cluster,
        RexBuilder rexBuilder, RelNode input, Set<Integer> inputKeyPositions,
        Set<String> pushedPredicates) {
  final List<RexNode> newConditions = Lists.newArrayList();
  for (int pos : inputKeyPositions) {//遍历输入字段的索引位置，并从行类型的字段列表获取盖RelDataType是否为可空，如果可不空，则跳过
    RelDataType keyType = input.getRowType().getFieldList().get(pos).getType();
    // Nothing to do if key cannot be null
    if (!keyType.isNullable()) {
      continue;
    }
    RexNode cond = rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL,
            rexBuilder.makeInputRef(input, pos));//给字段引用添加 is not null限制，生成新的RexNode表达式
    String digest = cond.toString();
    if (pushedPredicates.add(digest)) {//如果pushedPredicates不存在，则天道新条件行表达式RexNode列表中，返回
      newConditions.add(cond);
    }
  }
  return newConditions;
}

final Join join = call.rel(0);
RelNode lChild = join.getLeft();
RelNode rChild = join.getRight();
HiveRulesRegistry registry = call.getPlanner().getContext().unwrap(HiveRulesRegistry.class);
assert registry != null;
if (join.getJoinType() != JoinRelType.INNER) {//关联条件不是inner join内连接，将会不会做任何优化
  return;
}
if (join.getCondition().isAlwaysTrue()) {//join的关联条件判断是否一直为true，如果恒为true，类似笛卡尔积，则也不会做任何优化
  return;
}

JoinPredicateInfo joinPredInfo;
try {
  joinPredInfo = HiveCalciteUtil.JoinPredicateInfo.constructJoinPredicateInfo(join);
} catch (CalciteSemanticException e) {
  return;
}

Set<Integer> joinLeftKeyPositions = new HashSet<Integer>();
Set<Integer> joinRightKeyPositions = new HashSet<Integer>();
for (int i = 0; i < joinPredInfo.getEquiJoinPredicateElements().size(); i++) {
  JoinLeafPredicateInfo joinLeafPredInfo = joinPredInfo.
          getEquiJoinPredicateElements().get(i);
 joinLeftKeyPositions.addAll(joinLeafPredInfo.getProjsFromLeftPartOfJoinKeysInChildSchema());//提取出使用到谓词在schema中的索引
 joinRightKeyPositions.addAll(joinLeafPredInfo.getProjsFromRightPartOfJoinKeysInChildSchema());
}

// Build not null conditions
final RelOptCluster cluster = join.getCluster();
final RexBuilder rexBuilder = join.getCluster().getRexBuilder();

Set<String> leftPushedPredicates = Sets.newHashSet(registry.getPushedPredicates(join, 0));
final List<RexNode> newLeftConditions = getNotNullConditions(cluster,
        rexBuilder, join.getLeft(), joinLeftKeyPositions, leftPushedPredicates);
Set<String> rightPushedPredicates = Sets.newHashSet(registry.getPushedPredicates(join, 1));
final List<RexNode> newRightConditions = getNotNullConditions(cluster,
        rexBuilder, join.getRight(), joinRightKeyPositions, rightPushedPredicates);
//在join右侧输入RelNode，根据在schema中索引信息，提取对应索引对应的RexNode表达式，存放到行表达式的List，便于下面使用

// Nothing will be added to the expression
RexNode newLeftPredicate = RexUtil.composeConjunction(rexBuilder, newLeftConditions, false); //把所有谓词都用and连接起来
RexNode newRightPredicate = RexUtil.composeConjunction(rexBuilder, newRightConditions, false);
if (newLeftPredicate.isAlwaysTrue() && newRightPredicate.isAlwaysTrue()) {
  return;
}

if (!newLeftPredicate.isAlwaysTrue()) {//如果谓词表达式不恒为true
  RelNode curr = lChild;
  lChild = filterFactory.createFilter(lChild, newLeftPredicate);//创建带有谓词的join左侧输入RelNode
  call.getPlanner().onCopy(curr, lChild);//
}
if (!newRightPredicate.isAlwaysTrue()) {
  RelNode curr = rChild;
  rChild = filterFactory.createFilter(rChild, newRightPredicate);
  call.getPlanner().onCopy(curr, rChild);
}

Join newJoin = join.copy(join.getTraitSet(), join.getCondition(),
        lChild, rChild, join.getJoinType(), join.isSemiJoinDone());//从新创建新Join
call.getPlanner().onCopy(join, newJoin);//当关系表达式复制到类似表达式时调用

// Register information about created predicates
registry.getPushedPredicates(newJoin, 0).addAll(leftPushedPredicates);
registry.getPushedPredicates(newJoin, 1).addAll(rightPushedPredicates);
call.transformTo(newJoin);