RexNode rexSubQuery = RexSubQuery.in(subQueryDesc.getRexSubQuery(), ImmutableList.<RexNode>of(rexNodeLhs) ); return rexSubQuery; RexNode subQueryNode = RexSubQuery.exists(subQueryDesc.getRexSubQuery()); return subQueryNode; RexNode rexSubQuery = RexSubQuery.scalar(subQueryDesc.getRexSubQuery()); return rexSubQuery;
private boolean isAggZeroOnEmpty(RexSubQuery e) { //as this is corr scalar subquery with agg we expect one aggregate assert(e.getKind() == SqlKind.SCALAR_QUERY); assert(e.rel.getInputs().size() == 1); Aggregate relAgg = (Aggregate)e.rel.getInput(0); assert(relAgg.getAggCallList().size() == 1); //should only have one aggregate if(relAgg.getAggCallList().get(0).getAggregation().getKind() == SqlKind.COUNT) { return true; } return false; }
boolean isCorrScalarAgg, boolean hasNoWindowingAndNoGby) { switch (e.getKind()) { case SCALAR_QUERY: switch (e.getKind()) { case IN: fields.addAll(builder.fields()); if (e.getKind() == SqlKind.EXISTS) { logic = RelOptUtil.Logic.TRUE_FALSE; break; builder.project(builder.alias(builder.literal(true), "i" + e.rel.getId())); if(!variablesSet.isEmpty() && (e.getKind() == SqlKind.EXISTS || e.getKind() == SqlKind.IN)) { && (e.getKind() == SqlKind.EXISTS || e.getKind() == SqlKind.IN)) { final List<RexNode> conditions = new ArrayList<>(); for (Pair<RexNode, RexNode> pair : Pair.zip(e.getOperands(), builder.fields())) { conditions.add( builder.equals(pair.left, RexUtil.shift(pair.right, offset))); for (RexNode operand : e.getOperands()) { if (operand.getType().isNullable()) { keyIsNulls.add(builder.isNull(operand));
switch (kind) { case IN: return RexSubQuery.in(root.rel, list); case NOT_IN: return rexBuilder.makeCall(SqlStdOperatorTable.NOT, RexSubQuery.in(root.rel, list)); case SOME: return RexSubQuery.some(root.rel, list, (SqlQuantifyOperator) call.getOperator()); case ALL: return rexBuilder.makeCall(SqlStdOperatorTable.NOT, RexSubQuery.some(root.rel, list, negate((SqlQuantifyOperator) call.getOperator()))); default: rel = ((SingleRel) rel).getInput(); return RexSubQuery.exists(rel); query = Iterables.getOnlyElement(call.getOperandList()); root = convertQueryRecursive(query, false, null); return RexSubQuery.scalar(root.rel);
@Override public RexNode visitSubQuery(RexSubQuery subQuery) { if (shuttle != null) { RelNode r = subQuery.rel.accept(shuttle); // look inside sub-queries if (r != subQuery.rel) { subQuery = subQuery.clone(r); } } return super.visitSubQuery(subQuery); } }
public RexSubQuery clone(RelNode rel) { return new RexSubQuery(type, getOperator(), operands, rel); } }
/** Creates a SOME sub-query. * * <p>There is no ALL. For {@code x comparison ALL (sub-query)} use instead * {@code NOT (x inverse-comparison SOME (sub-query))}. * If {@code comparison} is {@code >} * then {@code negated-comparison} is {@code <=}, and so forth. */ public static RexSubQuery some(RelNode rel, ImmutableList<RexNode> nodes, SqlQuantifyOperator op) { assert op.kind == SqlKind.SOME; final RelDataType type = type(rel, nodes); return new RexSubQuery(type, op, nodes, rel); }
boolean allLiterals = RexUtil.allLiterals(e.getOperands()); final List<RexNode> expressionOperands = new ArrayList<>(e.getOperands()); final List<RexNode> keyIsNulls = e.getOperands().stream() .filter(operand -> operand.getType().isNullable()) .map(builder::isNull)
public Logic visitSubQuery(RexSubQuery subQuery, Logic arg) { if (!subQuery.getType().isNullable()) { if (arg == Logic.TRUE_FALSE_UNKNOWN) { arg = Logic.TRUE_FALSE; } } return end(subQuery, arg); }
/** Creates an EXISTS sub-query. */ public static RexSubQuery exists(RelNode rel) { final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); final RelDataType type = typeFactory.createSqlType(SqlTypeName.BOOLEAN); return new RexSubQuery(type, SqlStdOperatorTable.EXISTS, ImmutableList.of(), rel); }
private RexSubQuery(RelDataType type, SqlOperator op, ImmutableList<RexNode> operands, RelNode rel) { super(type, op, operands); this.rel = rel; this.digest = computeDigest(false); }
switch (kind) { case IN: return RexSubQuery.in(root.rel, list); case NOT_IN: return rexBuilder.makeCall(SqlStdOperatorTable.NOT, RexSubQuery.in(root.rel, list)); case SOME: return RexSubQuery.some(root.rel, list, (SqlQuantifyOperator) call.getOperator()); case ALL: return rexBuilder.makeCall(SqlStdOperatorTable.NOT, RexSubQuery.some(root.rel, list, negate((SqlQuantifyOperator) call.getOperator()))); default: rel = ((SingleRel) rel).getInput(); return RexSubQuery.exists(rel); query = Iterables.getOnlyElement(call.getOperandList()); root = convertQueryRecursive(query, false, null); return RexSubQuery.scalar(root.rel);
@Override public RexNode visitSubQuery(RexSubQuery subQuery) { if (shuttle != null) { RelNode r = subQuery.rel.accept(shuttle); // look inside sub-queries if (r != subQuery.rel) { subQuery = subQuery.clone(r); } } return super.visitSubQuery(subQuery); } }
public RexSubQuery clone(RelNode rel) { return new RexSubQuery(type, getOperator(), operands, rel); } }
/** Creates an IN sub-query. */ public static RexSubQuery in(RelNode rel, ImmutableList<RexNode> nodes) { final RelDataType type = type(rel, nodes); return new RexSubQuery(type, SqlStdOperatorTable.IN, nodes, rel); }
boolean allLiterals = RexUtil.allLiterals(e.getOperands()); final List<RexNode> expressionOperands = new ArrayList<>(e.getOperands()); final List<RexNode> keyIsNulls = e.getOperands().stream() .filter(operand -> operand.getType().isNullable()) .map(builder::isNull)
public Logic visitSubQuery(RexSubQuery subQuery, Logic arg) { if (!subQuery.getType().isNullable()) { if (arg == Logic.TRUE_FALSE_UNKNOWN) { arg = Logic.TRUE_FALSE; } } return end(subQuery, arg); }
/** Creates an EXISTS sub-query. */ public static RexSubQuery exists(RelNode rel) { final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); final RelDataType type = typeFactory.createSqlType(SqlTypeName.BOOLEAN); return new RexSubQuery(type, SqlStdOperatorTable.EXISTS, ImmutableList.of(), rel); }