public void onMatch(RelOptRuleCall call) { final ProjectRel project = call.rel(0); final RelNode child = project.getChild(); final RelDataType rowType = project.getRowType(); final RexProgram program = RexProgram.create( child.getRowType(), project.getProjects(), null, project.getRowType(), project.getCluster().getRexBuilder()); final CalcRel calc = new CalcRel( project.getCluster(), project.getTraitSet(), child, rowType, program, ImmutableList.<RelCollation>of()); call.transformTo(calc); } }
public UnifyResult apply(UnifyIn<ProjectRel, ProjectRel> in) { final RexShuttle shuttle = getRexShuttle(in.target); final List<RexNode> newProjects; try { newProjects = shuttle.apply(in.query.getProjects()); } catch (MatchFailed e) { return null; } final ProjectRel newProject = new ProjectRel( in.target.getCluster(), in.target, newProjects, in.query.getRowType(), in.query.getFlags(), in.query.getCollationList()); final RelNode newProject2 = RemoveTrivialProjectRule.strip(newProject); return in.result(newProject2); } }
public UnifyResult apply(UnifyIn<ProjectRel, FilterRel> in) { final Pair<RelNode, Integer> queryParent = in.parent(in.query); if (queryParent.left instanceof FilterRel) { final UnifyIn<FilterRel, FilterRel> in2 = in.create((FilterRel) queryParent.left); final FilterRel newFilter = FilterToFilterUnifyRule.INSTANCE.createFilter( in2.query, in2.target); if (newFilter == null) { return null; } return in2.result( in.query.copy( in.query.getTraitSet(), ImmutableList.<RelNode>of(newFilter))); } return null; } }
if (checkForDupExprs && (rel instanceof ProjectRel)) { ProjectRel project = (ProjectRel) rel; final List<RexNode> projectExprs = project.getProjects(); List<Integer> origins = new ArrayList<Integer>(); int dupCount = 0; new ProjectRel( cluster, rel, new ProjectRel( cluster, rel,
@Override public ProjectRel copy(RelTraitSet traitSet, RelNode input, List<RexNode> exps, RelDataType rowType) { return new ProjectRel(getCluster(), traitSet, input, exps, rowType, flags); }
public RelNode convert(RelNode rel) { final ProjectRel project = (ProjectRel) rel; if (B && RexMultisetUtil.containsMultiset(project.getProjects(), true) || RexOver.containsOver(project.getProjects(), null)) { return null; } return new EnumerableProjectRel( rel.getCluster(), rel.getTraitSet().replace(EnumerableConvention.INSTANCE), convert( project.getChild(), project.getChild().getTraitSet() .replace(EnumerableConvention.INSTANCE)), project.getProjects(), project.getRowType(), ProjectRelBase.Flags.BOXED); } }
@Override public void onMatch( RelOptRuleCall call ) { ProjectRel rel = call.rel( 0 ); RelTraitSet newTraits = rel.getTraitSet().plus( Cascading.CONVENTION ); call.transformTo( new CascadingProjectRel( rel.getCluster(), newTraits, convert( rel.getChild(), newTraits ), rel.getProjects(), rel.getRowType(), rel.getFlags(), rel.getCollationList() ) ); } }
public void onMatch(RelOptRuleCall call) { ProjectRel project = call.rel(0); List<RexNode> expList = new ArrayList<RexNode>(project.getChildExps()); if (reduceExpressions(project, expList)) { call.transformTo( new ProjectRel( project.getCluster(), project.getTraitSet(), project.getChild(), expList, project.getRowType(), ProjectRel.Flags.BOXED)); // New plan is absolutely better than old plan. call.getPlanner().setImportance(project, 0.0); } } };
RexProgram.create( calc.getRowType(), project.getProjects(), null, project.getRowType(), project.getCluster().getRexBuilder()); if (RexOver.containsOver(program)) { CalcRel projectAsCalc = new CalcRel( project.getCluster(), project.getTraitSet(), calc, project.getRowType(), program, Collections.<RelCollation>emptyList()); final RexBuilder rexBuilder = project.getCluster().getRexBuilder(); final RexProgramBuilder progBuilder = new RexProgramBuilder( calc.getRowType(), rexBuilder); for (Pair<RexNode, String> field : project.getNamedProjects()) { progBuilder.addProject(field.left, field.right); calc.getTraitSet(), calc.getChild(), project.getRowType(), mergedProgram, Collections.<RelCollation>emptyList());
/** Returns the child of a project if the project is trivial, otherwise * the project itself. */ public static RelNode strip(ProjectRel project) { RelNode child = project.getChild(); final RelDataType childRowType = child.getRowType(); if (!childRowType.isStruct()) { return project; } if (!project.isBoxed()) { return project; } if (!isIdentity( project.getProjects(), project.getRowType(), childRowType)) { return project; } return child; }
RexBuilder rexBuilder = project.getCluster().getRexBuilder(); RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory(); RelNode rightChild = semiJoin.getRight(); typeFactory.createJoinType( new RelDataType[] { project.getChild().getRowType(), rightChild.getRowType() }); for (Pair<RexNode, String> pair : project.getNamedProjects()) { bottomProgramBuilder.addProject(pair.left, pair.right); int nLeftFields = project.getChild().getRowType().getFieldCount(); List<RelDataTypeField> rightFields = rightChild.getRowType().getFieldList(); typeFactory.createJoinType( new RelDataType[] { project.getRowType(), rightChild.getRowType() });
public void onMatch(RelOptRuleCall call) { final FilterRel filter = call.rel(0); final ProjectRel project = call.rel(1); final List<RexNode> newProjects = new ArrayList<RexNode>(project.getProjects()); newProjects.add(filter.getCondition()); final RelOptCluster cluster = filter.getCluster(); RelDataType newRowType = cluster.getTypeFactory().builder() .addAll(project.getRowType().getFieldList()) .add("condition", Util.last(newProjects).getType()) .build(); final RelNode newProject = project.copy(project.getTraitSet(), project.getChild(), newProjects, newRowType); final RexInputRef newCondition = cluster.getRexBuilder().makeInputRef(newProject, newProjects.size() - 1); call.transformTo(new FilterRel(cluster, newProject, newCondition)); } }
public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) { assert traitSet.containsIfApplicable(Convention.NONE); return new ProjectRel( getCluster(), sole(inputs), getProjects(), rowType, getFlags(), collationList); }
((ProjectRel) insertRel.getInput(0)).getProjects(); if (insertRel.getInput(0).getInput(0) instanceof ProjectRel) { level2InsertExprs = ((ProjectRel) insertRel.getInput(0).getInput(0)) .getProjects(); final ProjectRel project = (ProjectRel) mergeSourceRel; projects.addAll( Util.skip(project.getProjects(), nSourceFields));
public void onMatch(RelOptRuleCall call) { final SortRel sort = call.rel(0); final ProjectRel project = call.rel(1); final RelOptCluster cluster = project.getCluster(); if (sort.getConvention() != project.getConvention()) { return; project.getProjects(), project.getChild().getRowType()); for (RelFieldCollation fc : sort.getCollation().getFieldCollations()) { if (map.getTargetOpt(fc.getFieldIndex()) < 0) { sort.copy( sort.getTraitSet().replace(newCollation), project.getChild(), newCollation, sort.offset, sort.fetch); RelNode newProject = project.copy( sort.getTraitSet(), ImmutableList.<RelNode>of(newSort)); ? ImmutableMap.<RelNode, RelNode>of(newSort, project.getChild()) : ImmutableMap.<RelNode, RelNode>of(); call.transformTo(newProject, equiv);
(ProjectRel) CalcRel.createProject( newMultiJoin, project.getProjects(), project.getRowType().getFieldNames());
/** * Returns the child of the project that will be used as input into the new * JoinRel once the projects are pulled above the JoinRel. * * @param call RelOptRuleCall * @param project project RelNode * @param leftChild true if the project corresponds to the left projection * @return child of the project that will be used as input into the new * JoinRel once the projects are pulled above the JoinRel */ protected RelNode getProjectChild( RelOptRuleCall call, ProjectRel project, boolean leftChild) { return project.getChild(); }
for (RexNode rex : project.getProjects()) { final RexNode rex2 = rex.accept(itemFinder); final RexNode rex3 = table.mongoTable, rowType, ops); final ProjectRel newProject = new ProjectRel(cluster, newTable, newProjects, project.getRowType(), ProjectRel.Flags.Boxed, Collections.<RelCollation>emptyList()); call.transformTo(newProject);
new ProjectRel( cluster, cluster.traitSetOf(RelCollationImpl.PRESERVE),