/** * 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); } }