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

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

public void onMatch(RelOptRuleCall call) {
  final Filter filter = call.rel(0);
  final RexBuilder rexBuilder = filter.getCluster().getRexBuilder();
  final RexNode condition = RexUtil.pullFactors(rexBuilder, filter.getCondition());
  // 1. 对Filter过滤器操作进行遍历，找到可转换的点
  RexTransformIntoInClause transformIntoInClause = new RexTransformIntoInClause(rexBuilder, filter,minNumORClauses);
  RexNode newCondition = transformIntoInClause.apply(condition);
  // 2. 合并IN clause 语句
  RexMergeInClause mergeInClause = new RexMergeInClause(rexBuilder);
  newCondition = mergeInClause.apply(newCondition);
  // 3. 比较Filter的谓词条件部分变换前和变换后是否相同
  if (newCondition.toString().equals(condition.toString())) {
    return;
  }
  // 4. 使用变换后的谓词表达式创建新Filter操作，并进行优化转换
  RelNode newFilter = filter.copy(filter.getTraitSet(), filter.getInput(), newCondition);
  call.transformTo(newFilter);
}

public RexNode visitCall(RexCall call) {
  RexNode node;
  switch (call.getKind()) {//调用 带有操作符的 表达式
    case AND:
      ImmutableList<RexNode> operands = RexUtil.flattenAnd(((RexCall) call).getOperands());//转换为AND连接 RexNode行表达式列表
      List<RexNode> newOperands = new ArrayList<RexNode>();
      for (RexNode operand: operands) {//遍历上述的 行表达式，如果一个行表达式，再含有Or操作符
        RexNode newOperand;
        if (operand.getKind() == SqlKind.OR) {
          try {
            newOperand = transformIntoInClauseCondition(rexBuilder,
                    filterOp.getRowType(), operand, minNumORClauses);//经过变换后，转换IN
            if (newOperand == null) {
              newOperand = operand;
            }
          } catch (SemanticException e) {
            LOG.error("Exception in HivePointLookupOptimizerRule", e);
            return call;
          }
        } else {//不含Or直接，作为新newOperand
          newOperand = operand;
        }
        newOperands.add(newOperand);//新操作数列表
      }
      node = RexUtil.composeConjunction(rexBuilder, newOperands, false);//合并And连接
      break;
    case OR:
      try {//如果Or连接，直接返回call
        node = transformIntoInClauseCondition(rexBuilder,
                filterOp.getRowType(), call, minNumORClauses);
        if (node == null) {
          return call;
        }
      } catch (SemanticException e) {
        LOG.error("Exception in HivePointLookupOptimizerRule", e);
        return call;
      }
      break;
    default:
      return super.visitCall(call);
  }
  return node;
}

private static RexNode transformIntoInClauseCondition(RexBuilder rexBuilder, RelDataType inputSchema,
        RexNode condition, int minNumORClauses) throws SemanticException {
  assert condition.getKind() == SqlKind.OR;

  // 1. We extract the information necessary to create the predicate for the new
  //    filter
  ListMultimap<RexInputRef,RexLiteral> columnConstantsMap = ArrayListMultimap.create();
  ImmutableList<RexNode> operands = RexUtil.flattenOr(((RexCall) condition).getOperands());//分解为Or连接的RexNode集合
  if (operands.size() < minNumORClauses) {//Or连接的个数小于 目标最小Or数，退出优化。
    // We bail out
    return null;
  }
  for (int i = 0; i < operands.size(); i++) {//遍历RexNode
    final List<RexNode> conjunctions = RelOptUtil.conjunctions(operands.get(i));//每个RexNode元素，再转换为AND连接的列表
    for (RexNode conjunction: conjunctions) {
      // 1.1. If it is not a RexCall, we bail out
      //如果不是表达式调用，则推出优化
      if (!(conjunction instanceof RexCall)) {
        return null;
      }
      // 1.2. We extract the information that we need
      RexCall conjCall = (RexCall) conjunction;
      if(conjCall.getOperator().getKind() == SqlKind.EQUALS) { //如果调用为"=" 表达式 ，如果 a=1
        if (conjCall.operands.get(0) instanceof RexInputRef &&
                conjCall.operands.get(1) instanceof RexLiteral) {
          RexInputRef ref = (RexInputRef) conjCall.operands.get(0);
          RexLiteral literal = (RexLiteral) conjCall.operands.get(1);
          columnConstantsMap.put(ref, literal);//加入 字段，常量值映射
          if (columnConstantsMap.get(ref).size() != i+1) {
            // If we have not added to this column before, we bail out
            return null;
          }
          //如果调用为"=" 表达式 ，如果 1 = a情况
        } else if (conjCall.operands.get(1) instanceof RexInputRef &&
                conjCall.operands.get(0) instanceof RexLiteral) {
          RexInputRef ref = (RexInputRef) conjCall.operands.get(1);
          RexLiteral literal = (RexLiteral) conjCall.operands.get(0);
          columnConstantsMap.put(ref, literal);//加入 字段，常量值映射
          if (columnConstantsMap.get(ref).size() != i+1) {//相同字段名称的 Or 常量，不等于 加入的个数，则推出优化，a=1 or a=3 or a= 8
            // If we have not added to this column before, we bail out
            return null;
          }
        } else {
          // Bail out
          return null;
        }
      } else {
        return null;
      }
    }
  }