@Override public SqlRexConvertlet get(SqlCall call) { if (call.getKind() == SqlKind.EXTRACT && call.getOperandList().get(1).getKind() != SqlKind.LITERAL) { // Avoid using the standard convertlet for EXTRACT(TIMEUNIT FROM col), since we want to handle it directly // in ExtractOperationConversion. return BYPASS_CONVERTLET; } else { final SqlRexConvertlet convertlet = table.get(call.getOperator()); return convertlet != null ? convertlet : StandardConvertletTable.INSTANCE.get(call); } }
RexNode cond = ge(rexBuilder, rexInterval, zero); rexInterval.getType(), pad, rexBuilder.makeLiteral(false)); RexNode sum = floor ? minus(rexBuilder, rexInterval, cast) : plus(rexBuilder, rexInterval, cast); ? case_(rexBuilder, rexInterval, cond, sum) : case_(rexBuilder, sum, cond, rexInterval); RexNode div = divideInt(rexBuilder, kase, factor); return multiply(rexBuilder, div, factor); return convertFunction(cx, (SqlFunction) call.getOperator(), call);
convertOverlapsOperand(cx, call.getParserPosition(), call.operand(0)); final RexNode r0 = left.left; final RexNode r1 = left.right; final Pair<RexNode, RexNode> right = convertOverlapsOperand(cx, call.getParserPosition(), call.operand(1)); final RexNode r2 = right.left; final RexNode r3 = right.right; RexNode leftSwap = le(rexBuilder, r0, r1); final RexNode s0 = case_(rexBuilder, leftSwap, r0, r1); final RexNode e0 = case_(rexBuilder, leftSwap, r1, r0); RexNode rightSwap = le(rexBuilder, r2, r3); final RexNode s1 = case_(rexBuilder, rightSwap, r2, r3); final RexNode e1 = case_(rexBuilder, rightSwap, r3, r2); return and(rexBuilder, ge(rexBuilder, e0, s1), ge(rexBuilder, e1, s0)); case CONTAINS: return and(rexBuilder, le(rexBuilder, s0, s1), ge(rexBuilder, e0, e1)); case PERIOD_EQUALS: return and(rexBuilder, eq(rexBuilder, s0, s1), eq(rexBuilder, e0, e1)); case PRECEDES: return le(rexBuilder, e0, s1); case IMMEDIATELY_PRECEDES:
addAlias(SqlStdOperatorTable.CHARACTER_LENGTH, SqlStdOperatorTable.CHAR_LENGTH); addAlias(SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NULL); addAlias(SqlStdOperatorTable.IS_NOT_UNKNOWN, SqlStdOperatorTable.IS_NOT_NULL); addAlias(SqlStdOperatorTable.PERCENT_REMAINDER, SqlStdOperatorTable.MOD); registerOp(SqlStdOperatorTable.CAST, this::convertCast); registerOp(SqlStdOperatorTable.IS_DISTINCT_FROM, (cx, call) -> convertIsDistinctFrom(cx, call, false)); registerOp(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM, (cx, call) -> convertIsDistinctFrom(cx, call, true)); registerOp(SqlStdOperatorTable.PLUS, this::convertPlus); registerOp(SqlStdOperatorTable.MINUS, (cx, call) -> { final RexCall e = (RexCall) StandardConvertletTable.this.convertCall(cx, call, call.getOperator()); switch (e.getOperands().get(0).getType().getSqlTypeName()) { case TIME: case TIMESTAMP: return convertDatetimeMinus(cx, SqlStdOperatorTable.MINUS_DATE, call); default:
SqlCall call) { final List<RexNode> list = convertExpressionList(cx, call.getOperandList(), op.getOperandTypeChecker().getConsistency()); final RexNode x = list.get(SqlBetweenOperator.VALUE_OPERAND); RexNode ge1 = ge(rexBuilder, x, y); RexNode le1 = le(rexBuilder, x, z); RexNode and1 = and(rexBuilder, ge1, le1); break; case SYMMETRIC: RexNode ge2 = ge(rexBuilder, x, z); RexNode le2 = le(rexBuilder, x, y); RexNode and2 = and(rexBuilder, ge2, le2); res = or(rexBuilder, and1, and2); break; default:
/** * Casts a RexNode value to the validated type of a SqlCall. If the value * was already of the validated type, then the value is returned without an * additional cast. */ public RexNode castToValidatedType( SqlRexContext cx, SqlCall call, RexNode value) { return castToValidatedType(call, value, cx.getValidator(), cx.getRexBuilder()); }
public RexNode convertArray( SqlRexContext cx, SqlArrayValueConstructor op, SqlCall call) { return convertCall(cx, call); }
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 convertDatetimeMinus( SqlRexContext cx, SqlDatetimeSubtractionOperator op, SqlCall call) { // Rewrite datetime minus final RexBuilder rexBuilder = cx.getRexBuilder(); final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE); final RelDataType resType = cx.getValidator().getValidatedNodeType(call); return rexBuilder.makeCall(resType, op, exprs.subList(0, 2)); }
public RexNode convertCall(SqlRexContext cx, SqlCall call) { return convertFloorCeil(cx, call); } }
private static List<RexNode> convertExpressionList(SqlRexContext cx, List<SqlNode> nodes, SqlOperandTypeChecker.Consistency consistency) { final List<RexNode> exprs = new ArrayList<>(); for (SqlNode node : nodes) { exprs.add(cx.convertExpression(node)); } if (exprs.size() > 1) { final RelDataType type = consistentType(cx, consistency, RexUtil.types(exprs)); if (type != null) { final List<RexNode> oldExprs = Lists.newArrayList(exprs); exprs.clear(); for (RexNode expr : oldExprs) { exprs.add(cx.getRexBuilder().ensureType(type, expr, true)); } } } return exprs; }
RexNode cond = ge(rexBuilder, rexInterval, zero); rexInterval.getType(), pad, rexBuilder.makeLiteral(false)); RexNode sum = floor ? minus(rexBuilder, rexInterval, cast) : plus(rexBuilder, rexInterval, cast); ? case_(rexBuilder, rexInterval, cond, sum) : case_(rexBuilder, sum, cond, rexInterval); RexNode div = divideInt(rexBuilder, kase, factor); return multiply(rexBuilder, div, factor); return convertFunction(cx, (SqlFunction) call.getOperator(), call);
convertOverlapsOperand(cx, call.getParserPosition(), call.operand(0)); final RexNode r0 = left.left; final RexNode r1 = left.right; final Pair<RexNode, RexNode> right = convertOverlapsOperand(cx, call.getParserPosition(), call.operand(1)); final RexNode r2 = right.left; final RexNode r3 = right.right; RexNode leftSwap = le(rexBuilder, r0, r1); final RexNode s0 = case_(rexBuilder, leftSwap, r0, r1); final RexNode e0 = case_(rexBuilder, leftSwap, r1, r0); RexNode rightSwap = le(rexBuilder, r2, r3); final RexNode s1 = case_(rexBuilder, rightSwap, r2, r3); final RexNode e1 = case_(rexBuilder, rightSwap, r3, r2); return and(rexBuilder, ge(rexBuilder, e0, s1), ge(rexBuilder, e1, s0)); case CONTAINS: return and(rexBuilder, le(rexBuilder, s0, s1), ge(rexBuilder, e0, e1)); case PERIOD_EQUALS: return and(rexBuilder, eq(rexBuilder, s0, s1), eq(rexBuilder, e0, e1)); case PRECEDES: return le(rexBuilder, e0, s1); case IMMEDIATELY_PRECEDES:
addAlias(SqlStdOperatorTable.CHARACTER_LENGTH, SqlStdOperatorTable.CHAR_LENGTH); addAlias(SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NULL); addAlias(SqlStdOperatorTable.IS_NOT_UNKNOWN, SqlStdOperatorTable.IS_NOT_NULL); addAlias(SqlStdOperatorTable.PERCENT_REMAINDER, SqlStdOperatorTable.MOD); registerOp(SqlStdOperatorTable.CAST, this::convertCast); registerOp(SqlStdOperatorTable.IS_DISTINCT_FROM, (cx, call) -> convertIsDistinctFrom(cx, call, false)); registerOp(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM, (cx, call) -> convertIsDistinctFrom(cx, call, true)); registerOp(SqlStdOperatorTable.PLUS, this::convertPlus); registerOp(SqlStdOperatorTable.MINUS, (cx, call) -> { final RexCall e = (RexCall) StandardConvertletTable.this.convertCall(cx, call, call.getOperator()); switch (e.getOperands().get(0).getType().getSqlTypeName()) { case TIME: case TIMESTAMP: return convertDatetimeMinus(cx, SqlStdOperatorTable.MINUS_DATE, call); default:
SqlCall call) { final List<RexNode> list = convertExpressionList(cx, call.getOperandList(), op.getOperandTypeChecker().getConsistency()); final RexNode x = list.get(SqlBetweenOperator.VALUE_OPERAND); RexNode ge1 = ge(rexBuilder, x, y); RexNode le1 = le(rexBuilder, x, z); RexNode and1 = and(rexBuilder, ge1, le1); break; case SYMMETRIC: RexNode ge2 = ge(rexBuilder, x, z); RexNode le2 = le(rexBuilder, x, y); RexNode and2 = and(rexBuilder, ge2, le2); res = or(rexBuilder, and1, and2); break; default:
/** * Casts a RexNode value to the validated type of a SqlCall. If the value * was already of the validated type, then the value is returned without an * additional cast. */ public RexNode castToValidatedType( SqlRexContext cx, SqlCall call, RexNode value) { return castToValidatedType(call, value, cx.getValidator(), cx.getRexBuilder()); }
public RexNode convertArray( SqlRexContext cx, SqlArrayValueConstructor op, SqlCall call) { return convertCall(cx, call); }
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 convertDatetimeMinus( SqlRexContext cx, SqlDatetimeSubtractionOperator op, SqlCall call) { // Rewrite datetime minus final RexBuilder rexBuilder = cx.getRexBuilder(); final List<SqlNode> operands = call.getOperandList(); final List<RexNode> exprs = convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE); final RelDataType resType = cx.getValidator().getValidatedNodeType(call); return rexBuilder.makeCall(resType, op, exprs.subList(0, 2)); }
public RexNode convertCall(SqlRexContext cx, SqlCall call) { return convertFloorCeil(cx, call); } }