@Override public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) { return new LimitPrel(getCluster(), traitSet, sole(inputs), offset, fetch, isPushDown()); }
private Prel newLimit(int offset, int fetch, Prel child) { return new LimitPrel(cluster, traits, child, rexBuilder.makeBigintLiteral(new BigDecimal(offset)), rexBuilder.makeBigintLiteral(new BigDecimal(fetch)) ); }
public static Prel addLimitPrel(Prel input, long fetchSize) { RexBuilder builder = input.getCluster().getRexBuilder(); return new LimitPrel( input.getCluster(), input.getTraitSet(), input, builder.makeBigintLiteral(BigDecimal.ZERO), builder.makeBigintLiteral(BigDecimal.valueOf(fetchSize))); }
@Override public void onMatch(RelOptRuleCall call) { final LimitPrel limit = (LimitPrel) call.rel(0); final UnionExchangePrel unionExchangePrel = (UnionExchangePrel) call.rel(1); RelNode child = unionExchangePrel.getInput(); final int offset = limit.getOffset() != null ? Math.max(0, RexLiteral.intValue(limit.getOffset())) : 0; final int fetch = Math.max(0, RexLiteral.intValue(limit.getFetch())); // child Limit uses conservative approach: use offset 0 and fetch = parent limit offset + parent limit fetch. final RexNode childFetch = limit.getCluster().getRexBuilder().makeExactLiteral(BigDecimal.valueOf(offset + fetch)); final RelNode limitUnderExchange = new LimitPrel(child.getCluster(), child.getTraitSet(), child, null, childFetch); final RelNode newUnionExch = new UnionExchangePrel(unionExchangePrel.getCluster(), unionExchangePrel.getTraitSet(), limitUnderExchange); final RelNode limitAboveExchange = new LimitPrel(limit.getCluster(), limit.getTraitSet(), newUnionExch, limit.getOffset(), limit.getFetch(), true); call.transformTo(limitAboveExchange); }
@Override public void onMatch(RelOptRuleCall call) { final SamplePrel sample = (SamplePrel) call.rel(0); final RelNode input = sample.getInput(); final RelNode convertedInput = convert(input, input.getTraitSet().plus(Prel.PHYSICAL)); final RexBuilder rexBuilder = input.getCluster().getRexBuilder(); final PlannerSettings plannerSettings = PrelUtil.getPlannerSettings(call.getPlanner()); final RexNode offset = rexBuilder.makeBigintLiteral(BigDecimal.ZERO); final RexNode limit = rexBuilder.makeBigintLiteral(BigDecimal.valueOf(SampleCrel.getSampleSizeAndSetMinSampleSize(plannerSettings, 1))); final LimitPrel sampleAsLimit = new LimitPrel(sample.getCluster(), sample.getTraitSet().plus(Prel.PHYSICAL), convertedInput, offset, limit); call.transformTo(sampleAsLimit); } }
@Override public void onMatch(RelOptRuleCall call) { final LimitRel limit = (LimitRel) call.rel(0); final RelNode input = limit.getInput(); final RelTraitSet traits = input.getTraitSet().plus(Prel.PHYSICAL).plus(DistributionTrait.SINGLETON); final RelNode convertedInput = convert(input, traits); LimitPrel newLimit = new LimitPrel(limit.getCluster(), limit.getTraitSet().plus(Prel.PHYSICAL).plus(DistributionTrait.SINGLETON), convertedInput, limit.getOffset(), limit.getFetch()); call.transformTo(newLimit); } }
@Override public void onMatch(RelOptRuleCall call) { final LimitPrel limit = (LimitPrel) call.rel(0); final SingleMergeExchangePrel smex = (SingleMergeExchangePrel) call.rel(1); final SortPrel sort = (SortPrel) call.rel(2); // First offset to include into results (inclusive). Null implies it is starting from offset 0 int offset = limit.getOffset() != null ? Math.max(0, RexLiteral.intValue(limit.getOffset())) : 0; int fetch = limit.getFetch() != null? Math.max(0, RexLiteral.intValue(limit.getFetch())) : 0; final TopNPrel topN = new TopNPrel(limit.getCluster(), sort.getTraitSet(), sort.getInput(), offset + fetch, sort.getCollation()); final LimitPrel newLimit = new LimitPrel(limit.getCluster(), limit.getTraitSet(), new SingleMergeExchangePrel(smex.getCluster(), smex.getTraitSet(), topN, sort.getCollation()), limit.getOffset(), limit.getFetch()); call.transformTo(newLimit); }