How to use

leastRestrictive

method

in

org.apache.calcite.rel.type.RelDataTypeFactory

/**
 * Adds explicit casts if Calcite's type system could not resolve the CASE branches to a common type.
 *
 * Calcite is more stricter than hive w.r.t type conversions.
 * If a CASE has branches with string/int/boolean branch types; there is no common type.
 */
private List<RexNode> adjustCaseBranchTypes(List<RexNode> nodes, RelDataType retType) {
 List<RelDataType> branchTypes = new ArrayList<>();
 for (int i = 0; i < nodes.size(); i++) {
  if (i % 2 == 1 || i == nodes.size() - 1) {
   branchTypes.add(nodes.get(i).getType());
  }
 }
 RelDataType commonType = cluster.getTypeFactory().leastRestrictive(branchTypes);
 if (commonType != null) {
  // conversion is possible; not changes are neccessary
  return nodes;
 }
 List<RexNode> newNodes = new ArrayList<>();
 for (int i = 0; i < nodes.size(); i++) {
  RexNode node = nodes.get(i);
  if (i % 2 == 1 || i == nodes.size() - 1) {
   newNodes.add(cluster.getRexBuilder().makeCast(retType, node));
  } else {
   newNodes.add(node);
  }
 }
 return newNodes;
}

return typeFactory.leastRestrictive(rowTypes);

private RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) {
 RexNode typeSafeRex = rex;
 if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) {
  RexBuilder rb = cluster.getRexBuilder();
  List<RexNode> fixedPredElems = new ArrayList<RexNode>();
  RelDataType commonType = cluster.getTypeFactory().leastRestrictive(
    RexUtil.types(((RexCall) rex).getOperands()));
  for (RexNode rn : ((RexCall) rex).getOperands()) {
   fixedPredElems.add(rb.ensureType(commonType, rn, true));
  }
  typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems);
 }
 return typeSafeRex;
}

public static RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) {
 RexNode typeSafeRex = rex;
 if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) {
  RexBuilder rb = cluster.getRexBuilder();
  List<RexNode> fixedPredElems = new ArrayList<RexNode>();
  RelDataType commonType = cluster.getTypeFactory().leastRestrictive(
    RexUtil.types(((RexCall) rex).getOperands()));
  for (RexNode rn : ((RexCall) rex).getOperands()) {
   fixedPredElems.add(rb.ensureType(commonType, rn, true));
  }
  typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems);
 }
 return typeSafeRex;
}

public static RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) {
 RexNode typeSafeRex = rex;
 if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) {
  RexBuilder rb = cluster.getRexBuilder();
  List<RexNode> fixedPredElems = new ArrayList<RexNode>();
  RelDataType commonType = cluster.getTypeFactory().leastRestrictive(
    RexUtil.types(((RexCall) rex).getOperands()));
  for (RexNode rn : ((RexCall) rex).getOperands()) {
   fixedPredElems.add(rb.ensureType(commonType, rn, true));
  }
  typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems);
 }
 return typeSafeRex;
}

private RexNode getTypeSafePred(RelOptCluster cluster, RexNode rex, RelDataType rType) {
 RexNode typeSafeRex = rex;
 if ((typeSafeRex instanceof RexCall) && HiveCalciteUtil.isComparisonOp((RexCall) typeSafeRex)) {
  RexBuilder rb = cluster.getRexBuilder();
  List<RexNode> fixedPredElems = new ArrayList<RexNode>();
  RelDataType commonType = cluster.getTypeFactory().leastRestrictive(
    RexUtil.types(((RexCall) rex).getOperands()));
  for (RexNode rn : ((RexCall) rex).getOperands()) {
   fixedPredElems.add(rb.ensureType(commonType, rn, true));
  }
  typeSafeRex = rb.makeCall(((RexCall) typeSafeRex).getOperator(), fixedPredElems);
 }
 return typeSafeRex;
}

final String name =
  fieldName.e != null ? fieldName.e : "expr$" + fieldName.i;
final RelDataType type = cluster.getTypeFactory().leastRestrictive(
  new AbstractList<RelDataType>() {
   public RelDataType get(int index) {

final String name =
    fieldName.e != null ? fieldName.e : "expr$" + fieldName.i;
final RelDataType type = cluster.getTypeFactory().leastRestrictive(
    new AbstractList<RelDataType>() {
     public RelDataType get(int index) {

final int c = col;
final RelDataType type =
  typeFactory.leastRestrictive(
    new AbstractList<RelDataType>() {
      public RelDataType get(int row) {

private RelDataType getComponentType(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 return typeFactory.leastRestrictive(argTypes);
}

protected RelDataType getComponentType(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 return typeFactory.leastRestrictive(argTypes);
}

private RelDataType getComponentType(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 return typeFactory.leastRestrictive(argTypes);
}

protected RelDataType getComponentType(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 return typeFactory.leastRestrictive(argTypes);
}

private RelDataType inferTypeFromOperands(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 assert (argTypes.size() % 2) == 1 : "odd number of arguments expected: "
   + argTypes.size();
 assert argTypes.size() > 1 : argTypes.size();
 List<RelDataType> thenTypes = new ArrayList<>();
 for (int j = 1; j < (argTypes.size() - 1); j += 2) {
  thenTypes.add(argTypes.get(j));
 }
 thenTypes.add(Iterables.getLast(argTypes));
 return typeFactory.leastRestrictive(thenTypes);
}

private RelDataType inferTypeFromOperands(
  RelDataTypeFactory typeFactory,
  List<RelDataType> argTypes) {
 assert (argTypes.size() % 2) == 1 : "odd number of arguments expected: "
   + argTypes.size();
 assert argTypes.size() > 1 : argTypes.size();
 List<RelDataType> thenTypes = new ArrayList<>();
 for (int j = 1; j < (argTypes.size() - 1); j += 2) {
  thenTypes.add(argTypes.get(j));
 }
 thenTypes.add(Iterables.getLast(argTypes));
 return typeFactory.leastRestrictive(thenTypes);
}

 private Pair<RelDataType, RelDataType> getComponentTypes(
   RelDataTypeFactory typeFactory,
   List<RelDataType> argTypes) {
  return Pair.of(
    typeFactory.leastRestrictive(Util.quotientList(argTypes, 2, 0)),
    typeFactory.leastRestrictive(Util.quotientList(argTypes, 2, 1)));
 }
}

 private Pair<RelDataType, RelDataType> getComponentTypes(
   RelDataTypeFactory typeFactory,
   List<RelDataType> argTypes) {
  return Pair.of(
    typeFactory.leastRestrictive(Util.quotientList(argTypes, 2, 0)),
    typeFactory.leastRestrictive(Util.quotientList(argTypes, 2, 1)));
 }
}

@Override protected RelDataType deriveRowType() {
 final List<RelDataType> inputRowTypes =
   Lists.transform(inputs, RelNode::getRowType);
 final RelDataType rowType =
   getCluster().getTypeFactory().leastRestrictive(inputRowTypes);
 if (rowType == null) {
  throw new IllegalArgumentException("Cannot compute compatible row type "
    + "for arguments to set op: "
    + Util.sepList(inputRowTypes, ", "));
 }
 return rowType;
}

@Override protected RelDataType deriveRowType() {
 final List<RelDataType> inputRowTypes =
   Lists.transform(inputs, RelNode::getRowType);
 final RelDataType rowType =
   getCluster().getTypeFactory().leastRestrictive(inputRowTypes);
 if (rowType == null) {
  throw new IllegalArgumentException("Cannot compute compatible row type "
    + "for arguments to set op: "
    + Util.sepList(inputRowTypes, ", "));
 }
 return rowType;
}

  @Override
  public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
    int nOperands = opBinding.getOperandCount();
    List<RelDataType> types = new ArrayList<>();
    for (int i = startTypeIdx; i < nOperands; i++) {
      RelDataType type = opBinding.getOperandType(i);
      if (SqlTypeUtil.isNumeric(type)) {
        types.add(type);
      } else {
        return opBinding.getOperandType(defaultTypeIdx);
      }
    }
    return opBinding.getTypeFactory().leastRestrictive(types);
  }
}