public RelNode convert(RelNode rel) { LogicalProject project = (LogicalProject) rel; return new JdbcRules.JdbcProject(rel.getCluster(), rel.getTraitSet().replace(this.out), convert( project.getInput(), project.getInput().getTraitSet().replace(this.out).simplify()), project.getProjects(), project.getRowType()); }
@Override public boolean matches(RelOptRuleCall call) { try { final LogicalProject project = call.rel(0); for (RexNode node : project.getChildExps()) { if (!checkedExpressions.get(node)) { return false; } } return true; } catch (ExecutionException e) { throw new IllegalStateException("Failure while trying to evaluate pushdown.", e); } } }
List<RexNode> projExprs = project.getProjects(); if (projExprs.size() != 1) { return; final RelOptCluster cluster = project.getCluster(); RelNode newProject = RelOptUtil.createProject(aggregate,
List<Pair<RexNode, String>> projects = project.getNamedProjects(); List<Pair<RexNode, String>> newProjects = new ArrayList<>(); Map<Integer, Integer> mapping = new HashMap<>(); if (newProjects.equals(project.getNamedProjects())) { return; relBuilder.push(project.getInput()); relBuilder.project(Pair.left(newProjects), Pair.right(newProjects)); relBuilder.aggregate(relBuilder.groupKey(newGroupSet, false, null), newAggrCalls.build());
@Override public RelNode convert(RelNode relNode) { final LogicalProject project = (LogicalProject) relNode; final RelTraitSet traitSet = project.getTraitSet().replace(out); return new ElasticsearchProject(project.getCluster(), traitSet, convert(project.getInput(), out), project.getProjects(), project.getRowType()); } }
RexBuilder rexBuilder = project.getCluster().getRexBuilder(); RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory(); RelNode rightChild = semiJoin.getRight(); project.getInput().getRowType(), rightChild.getRowType(), JoinRelType.INNER, for (Pair<RexNode, String> pair : project.getNamedProjects()) { bottomProgramBuilder.addProject(pair.left, pair.right); int nLeftFields = project.getInput().getRowType().getFieldCount(); List<RelDataTypeField> rightFields = rightChild.getRowType().getFieldList(); project.getRowType(), rightChild.getRowType(), JoinRelType.INNER,
public void onMatch(RelOptRuleCall call) { final LogicalFilter filter = call.rel(0); final LogicalProject project = call.rel(1); final List<RexNode> newProjects = new ArrayList<>(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.getInput(), newProjects, newRowType); final RexInputRef newCondition = cluster.getRexBuilder().makeInputRef(newProject, newProjects.size() - 1); call.transformTo(LogicalFilter.create(newProject, newCondition)); } }
@Override public RelNode visit(LogicalProject project) { final RenameConvertToConvertFromVisitor renameVisitor = new RenameConvertToConvertFromVisitor(project.getCluster().getRexBuilder(), table); final List<RexNode> projExpr = Lists.newArrayList(); for(RexNode rexNode : project.getChildExps()) { projExpr.add(rexNode.accept(unwrappingExpressionVisitor)); } project = project.copy(project.getTraitSet(), project.getInput(), projExpr, project.getRowType()); List<RexNode> exprList = new ArrayList<>(); boolean rewrite = false; for (RexNode rex : project.getChildExps()) { RexNode newExpr = rex.accept(renameVisitor); if (newExpr != rex) { rewrite = true; } exprList.add(newExpr); } if (rewrite == true) { LogicalProject newProject = project.copy(project.getTraitSet(), project.getInput(0), exprList, project.getRowType()); return visitChild(newProject, 0, project.getInput()); } return visitChild(project, 0, project.getInput()); }
inputs.add(mockInput); when(mockInput.getId()).thenReturn(1); when(mockProject.getId()).thenReturn(2); when(mockProject.getInputs()).thenReturn(inputs); when(mockProject.getInput()).thenReturn(mockInput); RelDataType mockRowType = mock(RelDataType.class); when(mockRowType.getFieldCount()).thenReturn(1); when(mockProject.getRowType()).thenReturn(mockRowType); RexNode mockRexField = mock(RexNode.class); List<Pair<RexNode, String>> namedProjects = new ArrayList<>(); namedProjects.add(Pair.of(mockRexField, "test_field")); when(mockProject.getNamedProjects()).thenReturn(namedProjects); StreamApplicationDescriptorImpl mockAppDesc = mock(StreamApplicationDescriptorImpl.class); OperatorSpec<Object, SamzaSqlRelMessage> mockInputOp = mock(OperatorSpec.class);
final RelOptCluster cluster = project.getCluster(); RexProgram program = RexProgram.create( calc.getRowType(), project.getProjects(), null, project.getRowType(), cluster.getRexBuilder()); if (RexOver.containsOver(program)) { calc.getRowType(), rexBuilder); for (Pair<RexNode, String> field : project.getNamedProjects()) { progBuilder.addProject(field.left, field.right);
RelNode input = rootPrj.getInput(); RelDataType inType = rootPrj.getRowType(); List<String> inFields = inType.getFieldNames(); List<RexNode> projExp = new ArrayList<>(); projExp.add(rootPrj.getProjects().get(i)); projFieldMapping.put(i, projFields.size()); projFields.add(Pair.of(projFields.size(), inFields.get(i))); rootPrj = LogicalProject.create(input, projExp, projRowType); if (rootSort != null) {
public List<RelCollation> get() { // CALCITE-88 return RelMdCollation.project(cluster.getMetadataQuery(), convertChild, project.getProjects()); } });
public RelNode visit(LogicalProject project) { return visitChild(project, 0, project.getInput()); }
public RelNode createProject(RelNode input, List<? extends RexNode> childExprs, List<String> fieldNames) { return LogicalProject.create(input, childExprs, fieldNames); } }
public void onMatch(RelOptRuleCall call) { LogicalProject rel = call.rel(0); RelNode rawInput = call.rel(1); RelNode input = convert(rawInput, PHYSICAL); if (subsetHack && input instanceof RelSubset) { RelSubset subset = (RelSubset) input; for (RelNode child : subset.getRels()) { // skip logical nodes if (child.getTraitSet().getTrait(ConventionTraitDef.INSTANCE) == Convention.NONE) { continue; } else { RelTraitSet outcome = child.getTraitSet().replace(PHYSICAL); call.transformTo( new PhysProj(rel.getCluster(), outcome, convert(child, outcome), rel.getChildExps(), rel.getRowType())); } } } else { call.transformTo( PhysProj.create(input, rel.getChildExps(), rel.getRowType())); } } }
public void onMatch(RelOptRuleCall call) { LogicalProject project = call.rel(0); MultiJoin multiJoin = call.rel(1); // if all inputs have their projFields set, then projection information // has already been pushed into each input boolean allSet = true; for (int i = 0; i < multiJoin.getInputs().size(); i++) { if (multiJoin.getProjFields().get(i) == null) { allSet = false; break; } } if (allSet) { return; } // create a new MultiJoin that reflects the columns in the projection // above the MultiJoin final RelBuilder relBuilder = call.builder(); MultiJoin newMultiJoin = RelOptUtil.projectMultiJoin(multiJoin, project); relBuilder.push(newMultiJoin) .project(project.getProjects(), project.getRowType().getFieldNames()); call.transformTo(relBuilder.build()); } }
new LogicalProject(cluster, window.getTraitSet(), window.getInput(), exps, builder.build()); final RelDataTypeFactory.Builder outputBuilder = cluster.getTypeFactory().builder(); outputBuilder.addAll(projectBelowWindow.getRowType().getFieldList()); for (Window.Group group : window.groups) { final ImmutableBitSet.Builder keys = ImmutableBitSet.builder(); for (RexNode rexNode : project.getChildExps()) { topProjExps.add(rexNode.accept(indexAdjustment)); final LogicalProject newTopProj = project.copy( newLogicalWindow.getTraitSet(), newLogicalWindow, topProjExps, project.getRowType());
@Override public RelNode visit(LogicalProject project) { List<RexNode> rexNodes = project.getChildExps(); RexNodeSyncopator syncopator = new RexNodeSyncopator(); for (RexNode node : rexNodes) { Map<RelNode, AbstractMap.SimpleEntry<String, RelOptTable>> map = node.accept(syncopator); if (map != null) { rootNodeSchemas.putAll(map); } } return project.getInput().accept(this); }
joinType.generatesNullsOnRight(); for (Pair<RexNode, String> pair : project.getNamedProjects()) { RexNode newProjExpr = removeCorrelationExpr(
@Override public LogicalProject copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType) { return new LogicalProject(getCluster(), traitSet, input, projects, rowType); }