switch (subQuery.logic) { case TRUE: return rexBuilder.makeLiteral(true); RexNode rexNode = rexBuilder.makeFieldAccess(rex, fieldCount - 1); rexNode = rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, rexNode); for (int i = 0; i < k; i++) { rexNode = rexBuilder.makeCall( SqlStdOperatorTable.AND, rexNode, rexBuilder.makeCall( SqlStdOperatorTable.IS_NOT_NULL, rexBuilder.makeFieldAccess(rex, i))); final RelDataType longType = typeFactory.createSqlType(SqlTypeName.BIGINT); final RexNode cRef = rexBuilder.makeInputRef(root, leftLeftCount); final RexNode ckRef = rexBuilder.makeInputRef(root, leftLeftCount + 1); final RexNode iRef = rexBuilder.makeInputRef(root, root.getRowType().getFieldCount() - 1); rexBuilder.makeExactLiteral(BigDecimal.ZERO, longType); final RexLiteral trueLiteral = rexBuilder.makeLiteral(true); final RexLiteral falseLiteral = rexBuilder.makeLiteral(false); final RexNode unknownLiteral = rexBuilder.makeNullLiteral(SqlTypeName.BOOLEAN);
public OptiqPreparingStmt( CatalogReader catalogReader, RelDataTypeFactory typeFactory, Schema schema, EnumerableRel.Prefer prefer, RelOptPlanner planner) { super(catalogReader, EnumerableConvention.INSTANCE); this.schema = schema; this.prefer = prefer; this.planner = planner; this.rexBuilder = new RexBuilder(typeFactory); }
0, reinterpretCast ? rexBuilder.makeReinterpretCast(histogramType, exprs.get(0), rexBuilder.makeLiteral(false)) : rexBuilder.makeCast(histogramType, exprs.get(0))); rexBuilder.getTypeFactory(), SqlStdOperatorTable.HISTOGRAM_AGG, exprs); rexBuilder.makeOver( SqlStdOperatorTable.HISTOGRAM_AGG .inferReturnType(bind), rexBuilder.makeCall( histogramType, histogramOp, if (reinterpretCast) { histogramCall = rexBuilder.makeReinterpretCast( type, histogramCall, rexBuilder.makeLiteral(false)); } else { histogramCall = rexBuilder.makeCast(type, histogramCall); needSum0 ? SqlStdOperatorTable.SUM0
RelDataTypeField leftField = catalogReader.field(leftRowType, name); RexNode left = rexBuilder.makeInputRef( leftField.getType(), leftField.getIndex()); catalogReader.field(rightRowType, name); RexNode right = rexBuilder.makeInputRef( rightField.getType(), leftRowType.getFieldList().size() + rightField.getIndex()); RexNode equalsCall = rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, left,
return rexBuilder.makeCast( type, rexBuilder.constantNull()); return rexBuilder.makeExactLiteral( bd, literal.createSqlType(typeFactory)); return rexBuilder.makeApproxLiteral((BigDecimal) value); case CHAR: return rexBuilder.makeCharLiteral((NlsString) value); case BOOLEAN: return rexBuilder.makeLiteral(((Boolean) value).booleanValue()); case BINARY: bitString = (BitString) value; return rexBuilder.makeBinaryLiteral(byteString); case SYMBOL: return rexBuilder.makeFlag((Enum) value); case TIMESTAMP: return rexBuilder.makeTimestampLiteral( (Calendar) value, ((SqlTimestampLiteral) literal).getPrec()); case TIME: return rexBuilder.makeTimeLiteral( (Calendar) value, ((SqlTimeLiteral) literal).getPrec()); case DATE: return rexBuilder.makeDateLiteral((Calendar) value);
boolean allowCast) { if (value == null) { return makeCast(type, constantNull); RexNode literalNotNull = makeLiteral(value, typeNotNull, allowCast); return makeAbstractCast(type, literalNotNull); value = clean(value, type); RexLiteral literal; final List<RexNode> operands; switch (type.getSqlTypeName()) { case CHAR: return makeCharLiteral(padRight((NlsString) value, type.getPrecision())); case VARCHAR: literal = makeCharLiteral((NlsString) value); if (allowCast) { return makeCast(type, literal); } else { return literal; return makeBinaryLiteral( padRight((ByteString) value, type.getPrecision())); case VARBINARY: literal = makeBinaryLiteral((ByteString) value); if (allowCast) { return makeCast(type, literal); } else { return literal;
type = toType(cluster.getTypeFactory(), jsonType); } else { type = rexBuilder.deriveReturnType(operator, rexOperands); return rexBuilder.makeCall(type, operator, rexOperands); if (i < rowType.getFieldCount()) { final RelDataTypeField field = rowType.getFieldList().get(i); return rexBuilder.makeInputRef(field.getType(), input); final Object jsonExpr = map.get("expr"); final RexNode expr = toRex(relInput, jsonExpr); return rexBuilder.makeFieldAccess(expr, field, true); final Object jsonType = map.get("type"); RelDataType type = toType(cluster.getTypeFactory(), jsonType); return rexBuilder.makeCorrel(type, correl); Util.enumVal(SqlTypeName.class, (String) map.get("type")); if (literal == null) { return rexBuilder.makeNullLiteral(sqlTypeName); return rexBuilder.makeLiteral((Boolean) o); } else if (o instanceof String) { return rexBuilder.makeLiteral((String) o); } else if (o instanceof Number) { final Number number = (Number) o; if (number instanceof Double || number instanceof Float) { return rexBuilder.makeApproxLiteral(
rexBuilder.makeCall( SqlStdOperatorTable.MULTIPLY, argRef, argRef); final int argSquaredOrdinal = lookupOrAdd(inputExprs, argSquared); null); final RexNode sumArgSquared = rexBuilder.addAggCall( sumArgSquaredAggCall, nGroups, null); final RexNode sumArg = rexBuilder.addAggCall( sumArgAggCall, nGroups, rexBuilder.makeCall( SqlStdOperatorTable.MULTIPLY, sumArg, sumArg); null); final RexNode countArg = rexBuilder.addAggCall( countArgAggCall, nGroups, rexBuilder.makeCall( SqlStdOperatorTable.DIVIDE, sumSquaredArg, countArg);
private RexNode makeCastBooleanToExact(RelDataType toType, RexNode exp) { final RexNode casted = makeCall( SqlStdOperatorTable.CASE, exp, makeExactLiteral(BigDecimal.ONE, toType), makeZeroLiteral(toType)); if (!exp.getType().isNullable()) { return casted; } return makeCall( toType, SqlStdOperatorTable.CASE, ImmutableList.<RexNode>of( makeCall(SqlStdOperatorTable.IS_NOT_NULL, exp), casted, makeNullLiteral(toType.getSqlTypeName()))); }
switch (type.getSqlTypeName()) { case CHAR: return makeCharLiteral( new NlsString(Util.spaces(type.getPrecision()), null, null)); case VARCHAR: literal = makeCharLiteral(new NlsString("", null, null)); if (allowCast) { return makeCast(type, literal); } else { return literal; return makeBinaryLiteral(new byte[type.getPrecision()]); case VARBINARY: literal = makeBinaryLiteral(new byte[0]); if (allowCast) { return makeCast(type, literal); } else { return literal; case BIGINT: case DECIMAL: return makeExactLiteral(BigDecimal.ZERO, type); case FLOAT: case REAL: case DOUBLE: return makeApproxLiteral(BigDecimal.ZERO, type); case BOOLEAN: return booleanFalse; case TIME:
final RexInputRef aRef = rexBuilder.makeInputRef(intType, 0); final RexInputRef bRef = rexBuilder.makeInputRef(intType, 1); final RexInputRef cRef = rexBuilder.makeInputRef(intType, 2); final RexInputRef dRef = rexBuilder.makeInputRef(intType, 3); final RexLiteral trueLiteral = rexBuilder.makeLiteral(true); final RexLiteral falseLiteral = rexBuilder.makeLiteral(false); final RexNode nullLiteral = rexBuilder.makeNullLiteral(SqlTypeName.INTEGER); final RexNode unknownLiteral = rexBuilder.makeNullLiteral(SqlTypeName.BOOLEAN); rexBuilder.makeCall(SqlStdOperatorTable.AND, unknownLiteral, trueLiteral); final RexNode andTrueUnknown = rexBuilder.makeCall(SqlStdOperatorTable.AND, trueLiteral, unknownLiteral); final RexNode andFalseTrue = rexBuilder.makeCall(SqlStdOperatorTable.AND, falseLiteral, trueLiteral);
rexBuilder.addAggCall( sumZeroCall, nGroups, rexBuilder.addAggCall( countCall, nGroups, aggCallMapping, ImmutableList.of(argType)); return rexBuilder.makeCall(SqlStdOperatorTable.CASE, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, countRef, rexBuilder.makeExactLiteral(BigDecimal.ZERO)), rexBuilder.constantNull(), sumZeroRef);
public void addGroupExpr(SqlNode expr) { RexNode convExpr = bb.convertExpression(expr); final RexNode rex = lookupGroupExpr(expr); if (rex != null) { return; // don't add duplicates, in e.g. "GROUP BY x, y, x" } groupExprs.add(expr); String name = nameMap.get(expr.toString()); addExpr(convExpr, name); final RelDataType type = convExpr.getType(); inputRefs.add(rexBuilder.makeInputRef(type, inputRefs.size())); }
(BigDecimal) value, type.getScale()); return rexBuilder.makeExactLiteral( roundedValue, type); return rexBuilder.makeCharLiteral( new NlsString( Util.rpad(unpadded.getValue(), type.getPrecision()),
private RexNode mod(RexBuilder rexBuilder, RelDataType resType, RexNode res, long val) { if (val == 1L) { return res; } return rexBuilder.makeCall(SqlStdOperatorTable.MOD, res, rexBuilder.makeExactLiteral(BigDecimal.valueOf(val), resType)); }
rexBuilder.addAggCall( sumCall, nGroups, ImmutableList.of(avgInputType)); RexNode denominatorRef = rexBuilder.addAggCall( countCall, nGroups, ImmutableList.of(avgInputType)); final RexNode divideRef = rexBuilder.makeCall( SqlStdOperatorTable.DIVIDE, numeratorRef, denominatorRef); return rexBuilder.makeCast( oldCall.getType(), divideRef);
assert leftKeys == null; setRoot(rel, false); return rexBuilder.makeRangeReference( root.getRowType(), 0, List<RexNode> newLeftInputExpr = Lists.newArrayList(); for (int i = 0; i < origLeftInputCount; i++) { newLeftInputExpr.add(rexBuilder.makeInputRef(root, i)); rel, rightKeys, rexBuilder); } else { joinCond = rexBuilder.makeLiteral(true); return rexBuilder.makeRangeReference( returnType, origLeftInputCount, false); } else { return rexBuilder.makeRangeReference( rel.getRowType(), leftFieldCount,
public RexNode apply(Pair<RexNode, SqlNode> pair) { return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, pair.left, bb.convertExpression(pair.right)); } }),
@Ignore @Test /** Tests that we can analyze a program with no inputs that outputs two * constants. */ public void testAnalyzeTwoConstantProgram() { final RelDataTypeFactory typeFactory = new FieldTypeFactory(); final RelDataType inputType = typeFactory.createStructType( new RelDataTypeFactory.FieldInfoBuilder() ); final RexBuilder builder = new RexBuilder( typeFactory ); final RexProgramBuilder programBuilder = new RexProgramBuilder( inputType, builder ); programBuilder.addProject( builder.makeExactLiteral( BigDecimal.ONE ), "x" ); programBuilder.addProject( builder.makeCharLiteral( new NlsString( "foo", null, null ) ), "y" ); final RexProgram program = programBuilder.getProgram(); final ProgramUtil.Analyzed analyze = ProgramUtil.analyze( program ); assertTrue( analyze.hasConstants ); assertFalse( analyze.hasFunctions ); assertNull( analyze.permutation ); assertFalse( analyze.isComplex ); } }
private RexNode convertJoinCondition( Blackboard bb, SqlNode condition, JoinConditionType conditionType, RelNode leftRel, RelNode rightRel) { if (condition == null) { return rexBuilder.makeLiteral(true); } bb.setRoot(ImmutableList.of(leftRel, rightRel)); replaceSubqueries(bb, condition, RelOptUtil.Logic.UNKNOWN_AS_FALSE); switch (conditionType) { case ON: bb.setRoot(ImmutableList.of(leftRel, rightRel)); return bb.convertExpression(condition); case USING: SqlNodeList list = (SqlNodeList) condition; List<String> nameList = new ArrayList<String>(); for (SqlNode columnName : list) { final SqlIdentifier id = (SqlIdentifier) columnName; String name = id.getSimple(); nameList.add(name); } return convertUsing(leftRel, rightRel, nameList); default: throw Util.unexpected(conditionType); } }