/** * Creates a call with an array of arguments. * * <p>If you already know the return type of the call, then * {@link #makeCall(org.eigenbase.reltype.RelDataType, org.eigenbase.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>This is the fundamental method called by all of the other <code> * makeCall</code> methods. If you derive a class from {@link RexBuilder}, * this is the only method you need to override.</p> */ public RexNode makeCall( SqlOperator op, List<? extends RexNode> exprs) { // TODO jvs 12-Jun-2010: Find a better place for this; // it surely does not belong here. if (op == SqlStdOperatorTable.andOperator && exprs.size() == 2 && exprs.get(0).equals(exprs.get(1))) { // Avoid generating 'AND(x, x)'; this can cause plan explosions if a // relnode is its own child and is merged with itself. return exprs.get(0); } final RelDataType type = deriveReturnType(op, typeFactory, exprs); return new RexCall(type, op, 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(); for (int i = 0; i < n; ++i) { initializationExprs.add( cx.getDefaultValueFactory().newAttributeInitializer( type, constructor, i, exprs)); } 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(); final RelDataTypeFactory typeFactory = cx.getTypeFactory(); RelDataType type = rexBuilder.deriveReturnType( constructor, typeFactory, exprs); int n = type.getFieldCount(); ImmutableList.Builder<RexNode> initializationExprs = ImmutableList.builder(); for (int i = 0; i < n; ++i) { initializationExprs.add( cx.getDefaultValueFactory().newAttributeInitializer( type, constructor, i, exprs)); } List<RexNode> defaultCasts = RexUtil.generateCastExpressions( rexBuilder, type, initializationExprs.build()); return rexBuilder.makeNewInvocation(type, defaultCasts); }
/** * Converts a CASE expression. */ public RexNode convertCase( SqlRexContext cx, SqlCase call) { SqlNodeList whenList = call.getWhenOperands(); SqlNodeList thenList = call.getThenOperands(); assert whenList.size() == thenList.size(); final List<RexNode> exprList = new ArrayList<RexNode>(); for (int i = 0; i < whenList.size(); i++) { exprList.add(cx.convertExpression(whenList.get(i))); exprList.add(cx.convertExpression(thenList.get(i))); } exprList.add(cx.convertExpression(call.getElseOperand())); RexBuilder rexBuilder = cx.getRexBuilder(); RelDataType type = rexBuilder.deriveReturnType(call.getOperator(), exprList); for (int i : elseArgs(exprList.size())) { exprList.set(i, rexBuilder.ensureType(type, exprList.get(i), false)); } return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, exprList); }
/** * Converts a CASE expression. */ public RexNode convertCase( SqlRexContext cx, SqlCase call) { SqlNodeList whenList = call.getWhenOperands(); SqlNodeList thenList = call.getThenOperands(); assert (whenList.size() == thenList.size()); final List<RexNode> exprList = new ArrayList<RexNode>(); for (int i = 0; i < whenList.size(); i++) { exprList.add(cx.convertExpression(whenList.get(i))); exprList.add(cx.convertExpression(thenList.get(i))); } exprList.add(cx.convertExpression(call.getElseOperand())); RexBuilder rexBuilder = cx.getRexBuilder(); RelDataType type = rexBuilder.deriveReturnType( call.getOperator(), cx.getTypeFactory(), exprList); for (int i : elseArgs(exprList.size())) { exprList.set( i, rexBuilder.ensureType(type, exprList.get(i), false)); } return rexBuilder.makeCall( SqlStdOperatorTable.caseOperator, exprList); }
/** * 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<RexNode>(); 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); }
type = toType(cluster.getTypeFactory(), jsonType); } else { type = rexBuilder.deriveReturnType(operator, rexOperands);
/** 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 List<RexNode> exprs = convertExpressionList(cx, operands); if (op.getOperandTypeChecker() == OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED) { ensureSameType(cx, exprs); } RelDataType type = rexBuilder.deriveReturnType(op, exprs); return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op)); }
newType = rexBuilder.deriveReturnType(operator, clonedOperands); } else {
public RexNode convertFunction( SqlRexContext cx, SqlFunction fun, SqlCall call) { final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = convertExpressionList(cx, operands); 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); }