Java RexNode.getKind方法代码示例

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
/**
 * Build the list of join conditions for this join.
 * A join condition is built only for equality and IS NOT DISTINCT FROM comparisons. The difference is:
 * null == null is FALSE whereas null IS NOT DISTINCT FROM null is TRUE
 * For a use case of the IS NOT DISTINCT FROM comparison, see
 * {@link org.apache.calcite.rel.rules.RemoveDistinctAggregateRule}
 * @param conditions populated list of join conditions
 * @param leftFields join fields from the left input
 * @param rightFields join fields from the right input
 */
protected void buildJoinConditions(List<JoinCondition> conditions,
    List<String> leftFields,
    List<String> rightFields,
    List<Integer> leftKeys,
    List<Integer> rightKeys) {
  List<RexNode> conjuncts = RelOptUtil.conjunctions(this.getCondition());
  short i=0;

  for (Pair<Integer, Integer> pair : Pair.zip(leftKeys, rightKeys)) {
    final RexNode conditionExpr = conjuncts.get(i++);
    final SqlKind kind  = conditionExpr.getKind();
    if (kind != SqlKind.EQUALS && kind != SqlKind.IS_NOT_DISTINCT_FROM) {
      throw UserException.unsupportedError()
          .message("Unsupported comparator in join condition %s", conditionExpr)
          .build(logger);
    }

    conditions.add(new JoinCondition(kind.toString(),
        FieldReference.getWithQuotedRef(leftFields.get(pair.left)),
        FieldReference.getWithQuotedRef(rightFields.get(pair.right))));
  }
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
/**
 * Returns whether a condition is supported by {@link JdbcJoin}.
 *
 * <p>Corresponds to the capabilities of
 * {@link JdbcJoin#convertConditionToSqlNode}.
 *
 * @param node Condition
 * @return Whether condition is supported
 */
private static boolean canJoinOnCondition(RexNode node) {
  final List<RexNode> operands;
  switch (node.getKind()) {
  case AND:
  case OR:
    operands = ((RexCall) node).getOperands();
    for (RexNode operand : operands) {
      if (!canJoinOnCondition(operand)) {
        return false;
      }
    }
    return true;

  case EQUALS:
  case IS_NOT_DISTINCT_FROM:
  case NOT_EQUALS:
  case GREATER_THAN:
  case GREATER_THAN_OR_EQUAL:
  case LESS_THAN:
  case LESS_THAN_OR_EQUAL:
    operands = ((RexCall) node).getOperands();
    if ((operands.get(0) instanceof RexInputRef)
        && (operands.get(1) instanceof RexInputRef)) {
      return true;
    }
    // fall through

  default:
    return false;
  }
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public RexNode makeCast(
  RelDataType type,
  RexNode exp,
  boolean matchNullability) {
  // Special case: bypassing Calcite for interval types
  if (!(exp instanceof RexLiteral)
      && SqlTypeUtil.isExactNumeric(type)
      && SqlTypeUtil.isInterval(exp.getType())) {
    return makeAbstractCast(type, exp);
  }
  RexNode castRexNode = super.makeCast(type, exp, matchNullability);

  // If we have a CAST(A, TYPE) and A is already of the same TYPE (including nullability),
  // then return just A.
  if (castRexNode instanceof RexCall
    && castRexNode.getKind() == SqlKind.CAST
    && castRexNode.getType().equals(((RexCall) castRexNode).getOperands().get(0).getType())) {
    return ((RexCall) castRexNode).getOperands().get(0);
  }

  // If the types do not match (especially nullability), then cast it.
  if (!castRexNode.getType().equals(type)) {
    return makeAbstractCast(type, castRexNode);
  }

  return castRexNode;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
private static int getRexInputRefIndex(RexNode operand) {
  if (SqlKind.INPUT_REF != operand.getKind()) {
    return -1;
  }
  return ((RexInputRef)operand).getIndex();
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
public static List<JoinInfo> getJoins(RelNode graph){
  JoinFinder finder = new JoinFinder(graph.getCluster().getMetadataQuery());
  graph.accept(finder);
  List<JoinInfo> definitions = new ArrayList<>();
  joins: for (JoinDefinition joinDefinition : finder.definitions) {
    int degrees = 0; // TODO: implement degrees in extract
    if (joinDefinition.getLeftTables().size() != 1
        || joinDefinition.getRightTables().size() != 1) {
      // this join is not exploitable
      continue;
    }
    List<String> leftTable = joinDefinition.getLeftTables().iterator().next();
    List<String> rightTable = joinDefinition.getRightTables().iterator().next();
    List<JoinConditionInfo> conditions = new ArrayList<>();
    RexNode joinCondition = joinDefinition.getJoinCondition();
    switch (joinCondition.getKind()) {
    // TODO and
    case EQUALS:
      final JoinConditionInfo equalsExtractCond = extractEquals(joinDefinition, (RexCall) joinCondition);
      if (equalsExtractCond == null) {
        continue joins;
      }
      conditions.add(equalsExtractCond);
      break;
    case AND:
      RexCall andCall = (RexCall) joinCondition;
      for (RexNode operand : andCall.getOperands()) {
        if (operand.getKind() == SqlKind.EQUALS) {
          final JoinConditionInfo equalsExtractEquals = extractEquals(joinDefinition, (RexCall) operand);
          if (equalsExtractEquals == null) {
            continue joins;
          }
          conditions.add(equalsExtractEquals);
        } else {
          // this join is not exploitable
          continue joins;
        }
      }
      break;
    default:
      // this join is not exploitable
      continue joins;
    }
    definitions.add(
        new JoinInfo(toJoinType(joinDefinition.getJoinType()), degrees)
        .setLeftTablePathList(leftTable)
        .setRightTablePathList(rightTable)
        .setConditionsList(conditions));
  }
  return definitions;
}