public static PlannerSettings getSettings(final RelOptCluster cluster) { return getPlannerSettings(cluster); }
@Override public Iterator<Prel> iterator() { return PrelUtil.iter(getInput()); } }
public static RelTraitSet fixTraits(RelOptRuleCall call, RelTraitSet set) { return fixTraits(call.getPlanner(), set); }
protected LogicalExpression toExpr(AggregateCall call, List<String> fn) { ParseContext context = new ParseContext(PrelUtil.getSettings(getCluster())); List<LogicalExpression> args = Lists.newArrayList(); for (Integer i : call.getArgList()) { final int indexInConstants = i - fn.size(); if (i < fn.size()) { args.add(new FieldReference(fn.get(i))); } else { final RexLiteral constant = constants.get(indexInConstants); LogicalExpression expr = RexToExpr.toExpr(context, getInput().getRowType(), getCluster().getRexBuilder(), constant); args.add(expr); } } // for count(1). if (args.isEmpty()) { args.add(new ValueExpressions.LongExpression(1l)); } return new FunctionCall(call.getAggregation().getName().toLowerCase(), args); }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery relMetadataQuery) { if(PrelUtil.getSettings(getCluster()).useDefaultCosting()) { //We use multiplier 0.05 for TopN operator, and 0.1 for Sort, to make TopN a preferred choice. return super.computeSelfCost(planner).multiplyBy(.1); } RelNode child = this.getInput(); double inputRows = relMetadataQuery.getRowCount(child); // int rowWidth = child.getRowType().getPrecision(); int numSortFields = this.collation.getFieldCollations().size(); double cpuCost = DremioCost.COMPARE_CPU_COST * numSortFields * inputRows * (Math.log(inputRows)/Math.log(2)); double diskIOCost = 0; // assume in-memory for now until we enforce operator-level memory constraints // TODO: use rowWidth instead of avgFieldWidth * numFields // avgFieldWidth * numFields * inputRows double numFields = this.getRowType().getFieldCount(); long fieldWidth = PrelUtil.getPlannerSettings(planner).getOptions() .getOption(ExecConstants.AVERAGE_FIELD_WIDTH_KEY).getNumVal(); double memCost = fieldWidth * numFields * inputRows; Factory costFactory = (Factory) planner.getCostFactory(); return costFactory.makeCost(inputRows, cpuCost, diskIOCost, 0, memCost); }
long sampleFetch = SampleCrel.getSampleSizeAndSetMinSampleSize(PrelUtil.getPlannerSettings(getCluster().getPlanner()), ElasticsearchSample.SAMPLE_SIZE_DENOMINATOR); fetch = fetch == null ? sampleFetch : Math.min(fetch, sampleFetch); output = PrelUtil.addLimitPrel(output, fetch);
final List<RelNode> inputs = union.getInputs(); List<RelNode> convertedInputList = Lists.newArrayList(); PlannerSettings settings = PrelUtil.getPlannerSettings(call.getPlanner()); boolean allHashDistributed = true; final PlannerSettings plannerSettings = PrelUtil.getPlannerSettings(call.getPlanner()); final RelTraitSet traitsChild; if (plannerSettings.getOptions().getOption(PlannerSettings.ENABLE_UNIONALL_ROUND_ROBIN)) { traitsChild = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL).plus(hashChild); convertedChild = convert(child, PrelUtil.fixTraits(call, traitsChild)); } else { RelTraitSet traitsChild = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL); convertedChild = convert(child, PrelUtil.fixTraits(call, traitsChild)); allHashDistributed = false;
final ProjectPushInfo columnInfoItemsExprs = PrelUtil.getColumns(scan.getRowType(), proj.getItemExprs()); if (columnInfoItemsExprs == null || columnInfoItemsExprs.isStarQuery()) { return;
final int lastColumnReferenced = PrelUtil.getLastUsedColumnReference(project.getProjects());
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { if(PrelUtil.getSettings(getCluster()).useDefaultCosting()) { return super.computeSelfCost(planner).multiplyBy(.1); } double totalInputRowCount = 0; for (int i = 0; i < this.getInputs().size(); i++) { totalInputRowCount += mq.getRowCount(this.getInputs().get(i)); } double cpuCost = totalInputRowCount * DremioCost.BASE_CPU_COST; Factory costFactory = (Factory)planner.getCostFactory(); return costFactory.makeCost(totalInputRowCount, cpuCost, 0, 0); }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { if(PrelUtil.getSettings(getCluster()).useDefaultCosting()) { return super.computeSelfCost(planner).multiplyBy(.1); } final RelNode child = this.getInput(); double inputRows = mq.getRowCount(child); int numGroupByFields = this.getGroupCount(); int numAggrFields = this.aggCalls.size(); // cpu cost of hashing each grouping key double cpuCost = DremioCost.HASH_CPU_COST * numGroupByFields * inputRows; // add cpu cost for computing the aggregate functions cpuCost += DremioCost.FUNC_CPU_COST * numAggrFields * inputRows; double diskIOCost = 0; // assume in-memory for now until we enforce operator-level memory constraints // TODO: use distinct row count // + hash table template stuff double factor = PrelUtil.getPlannerSettings(planner).getOptions() .getOption(ExecConstants.HASH_AGG_TABLE_FACTOR_KEY).getFloatVal(); long fieldWidth = PrelUtil.getPlannerSettings(planner).getOptions() .getOption(ExecConstants.AVERAGE_FIELD_WIDTH_KEY).getNumVal(); // table + hashValues + links double memCost = ( (fieldWidth * numGroupByFields) + IntHolder.WIDTH + IntHolder.WIDTH ) * inputRows * factor; Factory costFactory = (Factory) planner.getCostFactory(); return costFactory.makeCost(inputRows, cpuCost, diskIOCost, 0 /* network cost */, memCost); }
@Override public void onMatch(RelOptRuleCall call) { final Project proj = call.rel(0); final ScanCrel scan = call.rel(1); ProjectPushInfo columnInfo = PrelUtil.getColumns(scan.getRowType(), proj.getProjects()); // get TableBase, either wrapped in RelOptTable, or TranslatableTable. TableBase table = scan.getTable().unwrap(TableBase.class); if (columnInfo == null || columnInfo.isStarQuery()) { return; } ScanCrel newScan = scan.cloneWithProject(columnInfo.columns); List<RexNode> newProjects = Lists.newArrayList(); for (RexNode n : proj.getChildExps()) { newProjects.add(n.accept(columnInfo.getInputRewriter())); } final RelBuilder relBuilder = relBuilderFactory.create(proj.getCluster(), null); relBuilder.push(newScan); relBuilder.project(newProjects, proj.getRowType().getFieldNames()); final RelNode newProj = relBuilder.build(); if (newProj instanceof Project && ProjectRemoveRule.isTrivial((Project) newProj) && newScan.getRowType().getFullTypeString().equals(newProj.getRowType().getFullTypeString())) { call.transformTo(newScan); } else { if(newScan.getProjectedColumns().equals(scan.getProjectedColumns())) { // no point in doing a pushdown that doesn't change anything. return; } call.transformTo(newProj); } }
@Override public boolean matches(RelOptRuleCall call) { PlannerSettings settings = PrelUtil.getPlannerSettings(call.getPlanner()); return settings.isHashJoinEnabled(); }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { if(PrelUtil.getSettings(getCluster()).useDefaultCosting()) { return super.computeSelfCost(planner).multiplyBy(.1); } double totalInputRowCount = 0; for (int i = 0; i < this.getInputs().size(); i++) { totalInputRowCount += mq.getRowCount(this.getInputs().get(i)); } double cpuCost = totalInputRowCount * DremioCost.BASE_CPU_COST; Factory costFactory = (Factory)planner.getCostFactory(); return costFactory.makeCost(totalInputRowCount, cpuCost, 0, 0); }
@Override public Iterator<Prel> iterator() { return PrelUtil.iter(getInput()); }
@Override public void onMatch(RelOptRuleCall call) { final UnionRel union = (UnionRel) call.rel(0); final List<RelNode> inputs = union.getInputs(); List<RelNode> convertedInputList = Lists.newArrayList(); RelTraitSet traits = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL); try { for (int i = 0; i < inputs.size(); i++) { RelNode convertedInput = convert(inputs.get(i), PrelUtil.fixTraits(call, traits)); convertedInputList.add(convertedInput); } traits = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL).plus(DistributionTrait.SINGLETON); UnionDistinctPrel unionDistinct = new UnionDistinctPrel(union.getCluster(), traits, convertedInputList, false /* compatibility already checked during logical phase */); call.transformTo(unionDistinct); } catch (InvalidRelException e) { tracer.warn(e.toString()); } }
public static RelTraitSet fixTraits(RelOptPlanner cluster, RelTraitSet set) { if (getPlannerSettings(cluster).isSingleMode()) { return set.replace(DistributionTrait.ANY); } else { return set; } }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { if (PrelUtil.getSettings(getCluster()).useDefaultCosting()) { return super.computeSelfCost(planner).multiplyBy(.1); } RelNode child = this.getInput(); double inputRows = mq.getRowCount(child); int rowWidth = child.getRowType().getFieldCount() * DremioCost.AVG_FIELD_WIDTH; double hashCpuCost = DremioCost.HASH_CPU_COST * inputRows * distFields.size(); double svrCpuCost = DremioCost.SVR_CPU_COST * inputRows; double mergeCpuCost = DremioCost.COMPARE_CPU_COST * inputRows * (Math.log(numEndPoints)/Math.log(2)); double networkCost = DremioCost.BYTE_NETWORK_COST * inputRows * rowWidth; Factory costFactory = (Factory)planner.getCostFactory(); return costFactory.makeCost(inputRows, hashCpuCost + svrCpuCost + mergeCpuCost, 0, networkCost); }
@Override public Iterator<Prel> iterator() { return PrelUtil.iter(getInput()); }
private void createTransformRequest(RelOptRuleCall call, AggregateRel aggregate, RelNode input, RelTraitSet traits) throws InvalidRelException { final RelNode convertedInput = convert(input, PrelUtil.fixTraits(call, traits)); HashAggPrel newAgg = new HashAggPrel( aggregate.getCluster(), traits, convertedInput, aggregate.indicator, aggregate.getGroupSet(), aggregate.getGroupSets(), aggregate.getAggCallList(), OperatorPhase.PHASE_1of1); call.transformTo(newAgg); }