Refine search
right = filter.getInput(); removeCorrelationExpr(filter.getCondition(), false); left.getRowType().getFieldCount() + rightJoinKeys.get(0).getIndex(); } else if (cm.mapRefRelToCorRef.containsKey(project)) { left.getRowType().getFieldCount() + right.getRowType().getFieldCount() - 1; } else { return;
newWhereFilter = LogicalFilter.create( leftPartialQuery.getScan(),
@Override public RelNode convert(RelNode rel) { LogicalFilter filter = (LogicalFilter) rel; RelTraitSet origTraitSet = filter.getTraitSet(); RelTraitSet traitSet = origTraitSet.replace(OLAPRel.CONVENTION).simplify(); return new OLAPFilterRel(filter.getCluster(), traitSet, convert(filter.getInput(), filter.getInput().getTraitSet().replace(OLAPRel.CONVENTION)), filter.getCondition()); } }
public RelNode convert(RelNode rel) { LogicalFilter filter = (LogicalFilter) rel; return new JdbcRules.JdbcFilter(rel.getCluster(), rel.getTraitSet().replace(this.out), convert(filter.getInput(), filter.getInput().getTraitSet().replace(this.out).simplify()), filter.getCondition()); }
public void onMatch(RelOptRuleCall call) { final LogicalFilter filter = call.rel(0); final RelNode rel = filter.getInput(); // Create a program containing a filter. final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); final RelDataType inputRowType = rel.getRowType(); final RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder); programBuilder.addIdentity(); programBuilder.addCondition(filter.getCondition()); final RexProgram program = programBuilder.getProgram(); final LogicalCalc calc = LogicalCalc.create(rel, program); call.transformTo(calc); } }
@Override public RelNode convert(RelNode relNode) { final LogicalFilter filter = (LogicalFilter) relNode; final RelTraitSet traitSet = filter.getTraitSet().replace(out); return new ElasticsearchFilter(relNode.getCluster(), traitSet, convert(filter.getInput(), out), filter.getCondition()); } }
!= funcInputs.get(0).getRowType().getFieldCount()) { return; final RexNode condition = filter.getCondition(); RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); List<RelDataTypeField> origFields = funcRel.getRowType().getFieldList(); rexBuilder, origFields, funcInput.getRowType().getFieldList(), adjustments)); newFuncInputs.add( LogicalFilter.create(funcInput, newCondition));
@Override public RelNode visit(LogicalFilter filter) { final RelNode input = filter.getInput().accept(this); return new LogicalFilter( cluster, copyOf(filter.getTraitSet()), input, copyOf(filter.getCondition()), ImmutableSet.copyOf(filter.getVariablesSet()) ); }
@Override public RelNode visit(LogicalFilter filter) { final RexNode condition = filter.getCondition().accept(unwrappingExpressionVisitor); filter = filter.copy( filter.getTraitSet(), filter.getInput(), condition); return visitChild(filter, 0, filter.getInput()); }
@Override public RelNode visit(TableScan tableScan) { if (!(tableScan instanceof IncrementallyUpdateable)) { return tableScan; } final RelNode newScan = updateScan((IncrementallyUpdateable) tableScan); // build new filter to apply refresh condition. final RexBuilder rexBuilder = tableScan.getCluster().getRexBuilder(); final RexNode inputRef = rexBuilder.makeInputRef(newScan, newScan.getRowType().getField(UPDATE_COLUMN, false, false).getIndex()); final RexNode literal = generateLiteral(rexBuilder, tableScan.getCluster().getTypeFactory()); final RexNode condition = tableScan.getCluster().getRexBuilder().makeCall(SqlStdOperatorTable.GREATER_THAN, ImmutableList.of(inputRef, literal)); return LogicalFilter.create(newScan, condition); }
public RelNode convert(RelNode rel) { final LogicalFilter filter = (LogicalFilter) rel; return BindableFilter.create( convert(filter.getInput(), filter.getInput().getTraitSet() .replace(BindableConvention.INSTANCE)), filter.getCondition()); } }
public static DataContext of(RelNode targetRel, LogicalFilter queryRel) { return of(targetRel.getRowType(), queryRel.getCondition()); }
@Override public RelNode visit(final LogicalFilter filter) { final RelBuilder relBuilder = newCalciteRelBuilderWithoutContext(filter.getCluster()); RelNode input = filter.getInput().accept(this); relBuilder.push(input); RexNode newCondition = filter.getCondition().accept(new RexShuttle() { @Override public RexNode visitInputRef(RexInputRef inputRef) { return relBuilder.field(filter.getRowType().getFieldNames().get(inputRef.getIndex())); } }); relBuilder.filter(newCondition); return relBuilder.build(); }
void translate(final LogicalFilter filter, final String logicalOpId, final TranslatorContext context) { MessageStream<SamzaSqlRelMessage> inputStream = context.getMessageStream(filter.getInput().getId()); final int filterId = filter.getId(); MessageStream<SamzaSqlRelMessage> outputStream = inputStream.filter(new FilterTranslatorFunction(filterId, queryId, logicalOpId)); context.registerMessageStream(filterId, outputStream); context.registerRelNode(filterId, filter); } }
@Deprecated // to be removed before 2.0 public static RexNode splitCorrelatedFilterCondition( LogicalFilter filter, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys) { final List<RexNode> nonEquiList = new ArrayList<>(); splitCorrelatedFilterCondition( filter, filter.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList); // Convert the remainders into a list that are AND'ed together. return RexUtil.composeConjunction( filter.getCluster().getRexBuilder(), nonEquiList, true); }
final RelNode oldInput = rel.getInput(); Frame frame = getInvoke(oldInput); if (frame == null) { rel.getCondition(), rexBuilder, maxCnfNodeCount, final LogicalFilter newFilter = LogicalFilter.create( frame.r, remainingCondition, com.google.common.collect.ImmutableSet.copyOf(rel.getVariablesSet()));
public RelNode toRel( RelOptTable.ToRelContext context, RelOptTable relOptTable) { // Request all fields. RelNode rel = new QuarkTileScan(context.getCluster(), this.relOptTable, this.quarkTile, this.backingTable); //Create a filter RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); List<RexNode> filterArgs = Lists.newArrayList(); filterArgs.add(rexBuilder.makeInputRef(rel, this.quarkTile.groupingColumn)); filterArgs.add(rexBuilder.makeLiteral(bitSetToString(this.quarkTile.groupingValue))); rel = LogicalFilter.create(rel, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, filterArgs)); //Create a project list List<Integer> posList = Lists.newArrayList(); for (QuarkTile.Column quarkColumn : this.quarkTile.cubeColumns) { posList.add(quarkColumn.cubeOrdinal); } for (Lattice.Measure measure : this.quarkTile.measures) { posList.add(((QuarkTile.Measure) measure).ordinal); } return RelOptUtil.createProject(rel, posList); }
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)); } }
public RelNode visit(LogicalFilter filter) { return visitChild(filter, 0, filter.getInput()); }