/** Creates a call to a scalar operator. */ public RexNode call(SqlOperator operator, RexNode... operands) { final RexBuilder builder = cluster.getRexBuilder(); final List<RexNode> operandList = ImmutableList.copyOf(operands); final RelDataType type = builder.deriveReturnType(operator, operandList); if (type == null) { throw new IllegalArgumentException("cannot derive type: " + operator + "; operands: " + Lists.transform(operandList, FN_TYPE)); } return builder.makeCall(type, operator, operandList); }
/** Creates a call to a scalar operator. */ public RexNode call(SqlOperator operator, RexNode... operands) { final RexBuilder builder = cluster.getRexBuilder(); final List<RexNode> operandList = ImmutableList.copyOf(operands); final RelDataType type = builder.deriveReturnType(operator, operandList); if (type == null) { throw new IllegalArgumentException("cannot derive type: " + operator + "; operands: " + Lists.transform(operandList, FN_TYPE)); } return builder.makeCall(type, operator, operandList); }
call.getType(), rexBuilder.makeCall( rexBuilder.deriveReturnType(operator, clonedOperands), operator, clonedOperands), true); } else {
newType = rexBuilder.deriveReturnType(operator, clonedOperands); } else {
/** * Creates a call with an array of arguments. * * <p>If you already know the return type of the call, then * {@link #makeCall(org.apache.calcite.rel.type.RelDataType, org.apache.calcite.sql.SqlOperator, java.util.List)} * is preferred.</p> */ public RexNode makeCall( SqlOperator op, List<? extends RexNode> exprs) { final RelDataType type = deriveReturnType(op, exprs); return new RexCall(type, op, exprs); }
/** * Creates a call with an array of arguments. * * <p>If you already know the return type of the call, then * {@link #makeCall(org.apache.calcite.rel.type.RelDataType, org.apache.calcite.sql.SqlOperator, java.util.List)} * is preferred.</p> */ public RexNode makeCall( SqlOperator op, List<? extends RexNode> exprs) { final RelDataType type = deriveReturnType(op, exprs); return new RexCall(type, op, exprs); }
static int getReturnTypePrecision(SqlRexContext cx, SqlCall call) { return cx.getRexBuilder() .deriveReturnType(call.getOperator(), call.getOperandList() .stream() .map(cx::convertExpression) .collect(Collectors.toList())) .getPrecision(); } }
/** Creates a call to a scalar operator. */ private RexNode call(SqlOperator operator, List<RexNode> operandList) { final RexBuilder builder = cluster.getRexBuilder(); final RelDataType type = builder.deriveReturnType(operator, operandList); return builder.makeCall(type, operator, operandList); }
/** Creates a call to a scalar operator. */ private RexNode call(SqlOperator operator, List<RexNode> operandList) { final RexBuilder builder = cluster.getRexBuilder(); final RelDataType type = builder.deriveReturnType(operator, operandList); if (type == null) { throw new IllegalArgumentException("cannot derive type: " + operator + "; operands: " + Lists.transform(operandList, e -> e + ": " + e.getType())); } return builder.makeCall(type, operator, operandList); }
@Override public RexNode convertCall(SqlRexContext cx, SqlCall call) { final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = new LinkedList<>(); for (SqlNode node: operands) { exprs.add(cx.convertExpression(node)); } final RelDataType returnType = cx.getRexBuilder().deriveReturnType(call.getOperator(), exprs); return cx.getRexBuilder().makeCall(returnType, call.getOperator(), exprs); } };
private static RexNode makeConstructorCall( SqlRexContext cx, SqlFunction constructor, List<RexNode> exprs) { final RexBuilder rexBuilder = cx.getRexBuilder(); RelDataType type = rexBuilder.deriveReturnType(constructor, exprs); int n = type.getFieldCount(); ImmutableList.Builder<RexNode> initializationExprs = ImmutableList.builder(); final InitializerContext initializerContext = new InitializerContext() { public RexBuilder getRexBuilder() { return rexBuilder; } public RexNode convertExpression(SqlNode e) { throw new UnsupportedOperationException(); } }; for (int i = 0; i < n; ++i) { initializationExprs.add( cx.getInitializerExpressionFactory().newAttributeInitializer( type, constructor, i, exprs, initializerContext)); } List<RexNode> defaultCasts = RexUtil.generateCastExpressions( rexBuilder, type, initializationExprs.build()); return rexBuilder.makeNewInvocation(type, defaultCasts); }
private static RexNode makeConstructorCall( SqlRexContext cx, SqlFunction constructor, List<RexNode> exprs) { final RexBuilder rexBuilder = cx.getRexBuilder(); RelDataType type = rexBuilder.deriveReturnType(constructor, exprs); int n = type.getFieldCount(); ImmutableList.Builder<RexNode> initializationExprs = ImmutableList.builder(); final InitializerContext initializerContext = new InitializerContext() { public RexBuilder getRexBuilder() { return rexBuilder; } public RexNode convertExpression(SqlNode e) { throw new UnsupportedOperationException(); } }; for (int i = 0; i < n; ++i) { initializationExprs.add( cx.getInitializerExpressionFactory().newAttributeInitializer( type, constructor, i, exprs, initializerContext)); } List<RexNode> defaultCasts = RexUtil.generateCastExpressions( rexBuilder, type, initializationExprs.build()); return rexBuilder.makeNewInvocation(type, defaultCasts); }
/** * Converts a ROW. * * <p>Called automatically via reflection. */ public RexNode convertRow( SqlRexContext cx, SqlRowOperator op, SqlCall call) { if (cx.getValidator().getValidatedNodeType(call).getSqlTypeName() != SqlTypeName.COLUMN_LIST) { return convertCall(cx, call); } final RexBuilder rexBuilder = cx.getRexBuilder(); final List<RexNode> columns = new ArrayList<>(); for (SqlNode operand : call.getOperandList()) { columns.add( rexBuilder.makeLiteral( ((SqlIdentifier) operand).getSimple())); } final RelDataType type = rexBuilder.deriveReturnType(SqlStdOperatorTable.COLUMN_LIST, columns); return rexBuilder.makeCall(type, SqlStdOperatorTable.COLUMN_LIST, columns); }
/** * Converts a ROW. * * <p>Called automatically via reflection. */ public RexNode convertRow( SqlRexContext cx, SqlRowOperator op, SqlCall call) { if (cx.getValidator().getValidatedNodeType(call).getSqlTypeName() != SqlTypeName.COLUMN_LIST) { return convertCall(cx, call); } final RexBuilder rexBuilder = cx.getRexBuilder(); final List<RexNode> columns = new ArrayList<>(); for (SqlNode operand : call.getOperandList()) { columns.add( rexBuilder.makeLiteral( ((SqlIdentifier) operand).getSimple())); } final RelDataType type = rexBuilder.deriveReturnType(SqlStdOperatorTable.COLUMN_LIST, columns); return rexBuilder.makeCall(type, SqlStdOperatorTable.COLUMN_LIST, columns); }
rexBuilder.deriveReturnType(call.getOperator(), exprList); for (int i : elseArgs(exprList.size())) { exprList.set(i,
/** Converts a {@link SqlCall} to a {@link RexCall} with a perhaps different * operator. */ private RexNode convertCall( SqlRexContext cx, SqlCall call, SqlOperator op) { final List<SqlNode> operands = call.getOperandList(); final RexBuilder rexBuilder = cx.getRexBuilder(); final SqlOperandTypeChecker.Consistency consistency = op.getOperandTypeChecker() == null ? SqlOperandTypeChecker.Consistency.NONE : op.getOperandTypeChecker().getConsistency(); final List<RexNode> exprs = convertExpressionList(cx, operands, consistency); RelDataType type = rexBuilder.deriveReturnType(op, exprs); return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op)); }
/** Converts a {@link SqlCall} to a {@link RexCall} with a perhaps different * operator. */ private RexNode convertCall( SqlRexContext cx, SqlCall call, SqlOperator op) { final List<SqlNode> operands = call.getOperandList(); final RexBuilder rexBuilder = cx.getRexBuilder(); final SqlOperandTypeChecker.Consistency consistency = op.getOperandTypeChecker() == null ? SqlOperandTypeChecker.Consistency.NONE : op.getOperandTypeChecker().getConsistency(); final List<RexNode> exprs = convertExpressionList(cx, operands, consistency); RelDataType type = rexBuilder.deriveReturnType(op, exprs); return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op)); }
/** Converts a {@link SqlCall} to a {@link RexCall} with a perhaps different * operator. */ private RexNode convertCall( SqlRexContext cx, SqlCall call, SqlOperator op) { final List<SqlNode> operands = call.getOperandList(); final RexBuilder rexBuilder = cx.getRexBuilder(); final SqlOperandTypeChecker.Consistency consistency = op.getOperandTypeChecker() == null ? SqlOperandTypeChecker.Consistency.NONE : op.getOperandTypeChecker().getConsistency(); final List<RexNode> exprs = convertExpressionList(cx, operands, consistency); RelDataType type = rexBuilder.deriveReturnType(op, exprs); return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op)); }
public RexNode convertFunction( SqlRexContext cx, SqlFunction fun, SqlCall call) { final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE); if (fun.getFunctionType() == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR) { return makeConstructorCall(cx, fun, exprs); } RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call); if (returnType == null) { returnType = cx.getRexBuilder().deriveReturnType(fun, exprs); } return cx.getRexBuilder().makeCall(returnType, fun, exprs); }
public RexNode convertFunction( SqlRexContext cx, SqlFunction fun, SqlCall call) { final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE); if (fun.getFunctionType() == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR) { return makeConstructorCall(cx, fun, exprs); } RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call); if (returnType == null) { returnType = cx.getRexBuilder().deriveReturnType(fun, exprs); } return cx.getRexBuilder().makeCall(returnType, fun, exprs); }