public void visit(RelNode rel, int ordinal, RelNode parent) { // REVIEW: SWZ: 1/31/06: We assume that any special RelNodes, such // as the VolcanoPlanner's RelSubset always have a full complement // of traits and that they either appear as registered or do nothing // when childrenAccept is called on them. if (planner.isRegistered(rel)) { return; } RelTraitSet relTraits = rel.getTraitSet(); for (int i = 0; i < baseTraits.size(); i++) { if (i >= relTraits.size()) { // Copy traits that the new rel doesn't know about. Util.discard(RelOptUtil.addTrait(rel, baseTraits.getTrait(i))); // FIXME: Return the new rel. We can no longer traits in-place, // because rels and traits are immutable. throw new AssertionError(); } else { // Verify that the traits are from the same RelTraitDef assert relTraits.getTrait(i).getTraitDef() == baseTraits.getTrait(i).getTraitDef(); } } rel.childrenAccept(this); }
// implement RelNode public RelOptCost computeSelfCost(RelOptPlanner planner) { double dRows = RelMetadataQuery.getRowCount(this); // Assume CPU is negligible since values are precomputed. double dCpu = 1; double dIo = 0; return planner.makeCost(dRows, dCpu, dIo); }
public RelTraitSet traitSetOf(RelTrait... traits) { RelTraitSet traitSet = emptyTraitSet; assert traitSet.size() == planner.getRelTraitDefs().size(); for (RelTrait trait : traits) { traitSet = traitSet.replace(trait); } return traitSet; }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner) { // Higher cost if rows are wider discourages pushing a project through a // sort. double rowCount = RelMetadataQuery.getRowCount(this); double bytesPerRow = getRowType().getFieldCount() * 4; return planner.getCostFactory().makeCost(Util.nLogN(rowCount) * bytesPerRow, rowCount, 0); }
/** * Retrieves a materialized table that will satisfy an aggregate query on the star table. * * <p>The current implementation creates a materialization and populates it, provided that {@link * Lattice#auto} is true. * * <p>Future implementations might return materializations at a different level of aggregation, * from which the desired result can be obtained by rolling up. * * @param planner Current planner * @param groupSet Grouping key * @param measureList Calls to aggregate functions * @return Materialized table */ public Pair<CalciteSchema.TableEntry, TileKey> getAggregate( RelOptPlanner planner, ImmutableBitSet groupSet, List<Lattice.Measure> measureList) { final CalciteConnectionConfig config = planner.getContext().unwrap(CalciteConnectionConfig.class); if (config == null) { return null; } final MaterializationService service = MaterializationService.instance(); boolean create = lattice.auto && config.createMaterializations(); final CalciteSchema schema = starRelOptTable.unwrap(CalciteSchema.class); return service.defineTile(lattice, groupSet, measureList, schema, create, false); }
/** * Creates new RelNodes replacing/removing the original project/row scan * * @param projectedScan new scan that is now projected * @param origProject original projection * @param needRename true if fields from the row scan need to be renamed * @param newProject projection that contains the new projection expressions, in the case where * the original projection cannot be removed because it projects expressions * @return new RelNode */ public RelNode createNewRelNode( RelNode projectedScan, ProjectRel origProject, boolean needRename, ProjectRel newProject) { RelNode scanRel; if (needRename) { // Replace calling convention with FENNEL_EXEC_CONVENTION RelTraitSet traits = RelOptUtil.clone(origProject.getTraits()); traits.setTrait(CallingConventionTraitDef.instance, FennelRel.FENNEL_EXEC_CONVENTION); if (!traits.equals(projectedScan.getTraits())) { RelNode mergedProjectedScan = convert(projectedScan, traits); RelOptPlanner planner = projectedScan.getCluster().getPlanner(); // register projectedScan == mergedProjectedScan // so mergedProjectedScan will have a set later on projectedScan = planner.ensureRegistered(mergedProjectedScan, projectedScan); } scanRel = new FennelRenameRel( origProject.getCluster(), projectedScan, RelOptUtil.getFieldNames(origProject.getRowType()), traits); } else { scanRel = projectedScan; } if (newProject == null) { return scanRel; } else { // in the case where the projection had expressions, put the // new, modified projection on top of the projected row scan return (ProjectRel) CalcRel.createProject( scanRel, newProject.getProjectExps(), RelOptUtil.getFieldNames(newProject.getRowType())); } }
public OptiqPreparingStmt( CatalogReader catalogReader, RelDataTypeFactory typeFactory, Schema schema) { super(catalogReader); this.schema = schema; planner = new VolcanoPlanner(); planner.addRelTraitDef(CallingConventionTraitDef.instance); RelOptUtil.registerAbstractRels(planner); planner.addRule(JavaRules.ENUMERABLE_JOIN_RULE); planner.addRule(JavaRules.ENUMERABLE_CALC_RULE); planner.addRule(JavaRules.ENUMERABLE_AGGREGATE_RULE); planner.addRule(JavaRules.ENUMERABLE_SORT_RULE); planner.addRule(JavaRules.ENUMERABLE_UNION_RULE); planner.addRule(JavaRules.ENUMERABLE_INTERSECT_RULE); planner.addRule(JavaRules.ENUMERABLE_MINUS_RULE); planner.addRule(TableAccessRule.instance); rexBuilder = new RexBuilder(typeFactory); }
/** Creates a cluster. */ RelOptCluster( RelOptQuery query, RelOptPlanner planner, RelDataTypeFactory typeFactory, RexBuilder rexBuilder) { assert planner != null; assert typeFactory != null; this.query = query; this.planner = planner; this.typeFactory = typeFactory; this.rexBuilder = rexBuilder; this.originalExpression = rexBuilder.makeLiteral("?"); // set up a default rel metadata provider, // giving the planner first crack at everything metadataProvider = new DefaultRelMetadataProvider(); this.emptyTraitSet = planner.emptyTraitSet(); }
public RelOptCost computeSelfCost(RelOptPlanner planner) { double dRows = RelMetadataQuery.getRowCount(this); double dCpu = RelMetadataQuery.getRowCount(getChild()) * program.getExprCount(); double dIo = 0; return planner.makeCost(dRows, dCpu, dIo); }
// implement RelNode public RelOptCost computeSelfCost(RelOptPlanner planner) { return planner.makeTinyCost(); }