Refine search
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final Project 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(filter.copy(filter.getTraitSet(), newProject, newCondition)); } }
@Override public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); final RexNode condition = RexUtil.pullFactors(rexBuilder, filter.getCondition()); RexNode newCondition = analyzeRexNode(rexBuilder, condition); // If we could not transform anything, we bail out if (newCondition.toString().equals(condition.toString())) { return; } RelNode newNode = filter.copy(filter.getTraitSet(), filter.getInput(), newCondition); call.transformTo(newNode); } }
final Filter filter = call.rel(0); final RexSubQuery e = RexUtil.SubQueryFinder.find(filter.getCondition()); assert e != null; ImmutableList.of(filter.getCondition()), e); builder.push(filter.getInput()); final int fieldCount = builder.peek().getRowType().getFieldCount(); SubqueryConf subqueryConfig = filter.getCluster().getPlanner(). getContext().unwrap(SubqueryConf.class); boolean isCorrScalarQuery = subqueryConfig.getCorrScalarRexSQWithAgg().contains(e.rel); builder, 1, fieldCount, isCorrScalarQuery, hasNoWindowingAndNoGby); final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target); builder.filter(shuttle.apply(filter.getCondition())); builder.project(fields(builder, filter.getRowType().getFieldCount())); call.transformTo(builder.build()); } else if(relNode instanceof Project) { project.getProjects(), e); builder.push(project.getInput()); final int fieldCount = builder.peek().getRowType().getFieldCount(); project.getCluster().getPlanner().getContext().unwrap(SubqueryConf.class); boolean isCorrScalarQuery = subqueryConfig.getCorrScalarRexSQWithAgg().contains(e.rel); boolean hasNoWindowingAndNoGby =
public RelNode align(Filter rel, List<RelFieldCollation> collations) { final RelNode child = dispatchAlign(rel.getInput(), collations); return rel.copy(rel.getTraitSet(), ImmutableList.of(child)); }
@Override public RelNode convert(RelNode rel) { final Filter filter = (Filter) rel; final RelNode input = filter.getInput(); return new StreamsFilterRel(filter.getCluster(), filter.getTraitSet().replace(StreamsLogicalConvention.INSTANCE), convert(input, input.getTraitSet().replace(StreamsLogicalConvention.INSTANCE)), filter.getCondition()); } }
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final Project project = call.rel(1); if (RexOver.containsOver(project.getProjects(), null)) { if (RexUtil.containsCorrelation(filter.getCondition())) { RexNode newCondition = RelOptUtil.pushPastProject(filter.getCondition(), project); final RelDataTypeFactory typeFactory = filter.getCluster().getTypeFactory(); if (RexUtil.isNullabilityCast(typeFactory, newCondition)) { newCondition = ((RexCall) newCondition).getOperands().get(0); RelNode newFilterRel = filterFactory == null ? filter.copy(filter.getTraitSet(), project.getInput(), newCondition) : filterFactory.createFilter(project.getInput(), newCondition); RelNode newProjRel = projectFactory == null ? project.copy(project.getTraitSet(), newFilterRel, project.getProjects(), project.getRowType()) : projectFactory.createProject(newFilterRel, project.getProjects(), project.getRowType().getFieldNames()); call.transformTo(newProjRel);
@Override public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final List<RexNode> expList = Lists.newArrayList(filter.getCondition()); RexNode newConditionExp; boolean reduced; final RelMetadataQuery mq = call.getMetadataQuery(); final RelOptPredicateList predicates = mq.getPulledUpPredicates(filter.getInput()); if (reduceExpressions(filter, expList, predicates, true, false)) { assert expList.size() == 1; newConditionExp = filter.getCondition(); reduced = false; if (newConditionExp.isAlwaysTrue()) { call.transformTo( filter.getInput()); } else if (reduced) { if (RexUtil.isNullabilityCast(filter.getCluster().getTypeFactory(), newConditionExp)) { newConditionExp = ((RexCall) newConditionExp).getOperands().get(0); call.transformTo(call.builder(). push(filter.getInput()).filter(newConditionExp).build()); } else { if (newConditionExp instanceof RexCall) {
@Override public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); RexNode topFilterCondition = RexUtil.pullFactors(rexBuilder, filter.getCondition()); List<RexNode> nonDeterministicExprs = new ArrayList<>(); if (operand.getKind() == SqlKind.OR) { extractedCommonOperands = extractCommonOperands(rexBuilder, filter.getInput(), operand, maxCNFNodeCount); for (RexNode extractedExpr : extractedCommonOperands) { if (operandsToPushDownDigest.add(extractedExpr.toString())) { operandsToPushDown.add(extractedExpr); operandsToPushDown = extractCommonOperands(rexBuilder, filter.getInput(), topFilterCondition, maxCNFNodeCount); break; default: final List<RexNode> newConjuncts = HiveCalciteUtil.getPredsNotPushedAlready(filter.getInput(), operandsToPushDown); RexNode newPredicate = RexUtil.composeConjunction(rexBuilder, newConjuncts, false); RelNode newChildFilter = filterFactory.createFilter(filter.getInput(), newChildFilterCondition); RelNode newTopFilter = filterFactory.createFilter(newChildFilter, topFilterCondition); call.transformTo(newTopFilter);
final List<RexNode> aggOutputProjects = aggOutputProject.getProjects(); if (aggOutputProjects.size() != 1) { return; final List<RexNode> aggInputProjects = aggInputProject.getProjects(); right = filter.getInput(); removeCorrelationExpr(filter.getCondition(), false); } else if (cm.mapRefRelToCorRef.containsKey(aggInputProject)) { int nFields = left.getRowType().getFieldCount(); ImmutableBitSet allCols = ImmutableBitSet.range(nFields); int leftInputFieldCount = leftInputFieldType.getFieldCount(); int joinOutputProjExprCount = leftInputFieldCount + aggInputProjects.size() + 1; int nullIndicatorPos = join.getRowType().getFieldCount() - 1; cluster.getTypeFactory().createTypeWithNullability( join.getRowType().getFieldList() .get(nullIndicatorPos).getType(),
public void onMatch(RelOptRuleCall call) { Filter filterRel = call.rel(0); SetOp setOp = call.rel(1); RexNode condition = filterRel.getCondition(); RexBuilder rexBuilder = filterRel.getCluster().getRexBuilder(); final RelBuilder relBuilder = call.builder(); List<RelDataTypeField> origFields = setOp.getRowType().getFieldList(); int[] adjustments = new int[origFields.size()]; final List<RelNode> newSetOpInputs = new ArrayList<>(); for (int index = 0; index < setOp.getInputs().size(); index++) { RelNode input = setOp.getInput(index); RexNode newCondition = condition.accept(new RelOptUtil.RexInputConverter(rexBuilder, origFields, input.getRowType().getFieldList(), adjustments)); if (setOp instanceof Union && setOp.all) { final RelMetadataQuery mq = call.getMetadataQuery(); listBuilder.add(newCondition); RexExecutor executor = Util.first(filterRel.getCluster().getPlanner().getExecutor(), RexUtil.EXECUTOR); final RexSimplify simplify = new RexSimplify(rexBuilder, true, executor); final RexNode x = simplify.simplifyAnds(listBuilder.build()); if (x.isAlwaysFalse()) { call.transformTo( relBuilder.push(result).convert(filterRel.getRowType(), false).build());
public void onMatch(RelOptRuleCall call) { Filter filterRel = call.rel(0); SetOp setOp = call.rel(1); RexNode condition = filterRel.getCondition(); RexBuilder rexBuilder = filterRel.getCluster().getRexBuilder(); final RelBuilder relBuilder = call.builder(); List<RelDataTypeField> origFields = setOp.getRowType().getFieldList(); int[] adjustments = new int[origFields.size()]; final List<RelNode> newSetOpInputs = new ArrayList<>(); for (RelNode input : setOp.getInputs()) { RexNode newCondition = condition.accept( new RelOptUtil.RexInputConverter( rexBuilder, origFields, input.getRowType().getFieldList(), adjustments)); newSetOpInputs.add(relBuilder.push(input).filter(newCondition).build());
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final Project origproject = call.rel(1); RexNode filterCondToPushBelowProj = filter.getCondition(); RexNode unPushedFilCondAboveProj = null; if (RexOver.containsOver(origproject.getProjects(), null)) { RexNode origFilterCond = filterCondToPushBelowProj; filterCondToPushBelowProj = null; if (pushThroughWindowing) { Set<Integer> commonPartitionKeys = getCommonPartitionCols(origproject.getProjects()); List<RexNode> newPartKeyFilConds = new ArrayList<RexNode>(); List<RexNode> unpushedFilConds = new ArrayList<RexNode>(); filterCondToPushBelowProj = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), newPartKeyFilConds, true); unPushedFilCondAboveProj = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), unpushedFilConds, true); RelNode newProjRel = getNewProject(filterCondToPushBelowProj, unPushedFilCondAboveProj, origproject, filter.getCluster() .getTypeFactory(), call.builder()); call.transformTo(newProjRel);
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final RelBuilder builder = call.builder(); builder.push(filter.getInput()); int count = 0; RexNode c = filter.getCondition(); while (true) { final RexSubQuery e = RexUtil.SubQueryFinder.find(c); if (e == null) { assert count > 0; break; } ++count; final RelOptUtil.Logic logic = LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(c), e); final Set<CorrelationId> variablesSet = RelOptUtil.getVariablesUsed(e.rel); final RexNode target = apply(e, variablesSet, logic, builder, 1, builder.peek().getRowType().getFieldCount()); final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target); c = c.accept(shuttle); } builder.filter(c); builder.project(fields(builder, filter.getRowType().getFieldCount())); call.transformTo(builder.build()); } }
public void onMatch(RelOptRuleCall call) { Filter oldFilter = call.rel(0); RexNode oldFilterCond = oldFilter.getCondition(); if (RexUtil.findOperatorCall( SqlStdOperatorTable.IS_NOT_DISTINCT_FROM, oldFilterCond) == null) { // no longer contains isNotDistinctFromOperator return; } // Now replace all the "a isNotDistinctFrom b" // with the RexNode given by RelOptUtil.isDistinctFrom() method RemoveIsNotDistinctFromRexShuttle rewriteShuttle = new RemoveIsNotDistinctFromRexShuttle( oldFilter.getCluster().getRexBuilder()); final RelBuilder relBuilder = call.builder(); final RelNode newFilterRel = relBuilder .push(oldFilter.getInput()) .filter(oldFilterCond.accept(rewriteShuttle)) .build(); call.transformTo(newFilterRel); }
public void onMatch(RelOptRuleCall call) { final Project project = call.rel(0); final Filter filter = call.rel(1); final RelBuilder builder = call.builder(); List<RexNode> projects = project.getChildExps(); List<RexNode> newProjects = rewriteProjects(projects, filter.getCondition(), builder); if (newProjects == null) { return; } RelNode newProjRel = builder.push(filter) .project(newProjects, project.getRowType().getFieldNames()).build(); call.transformTo(newProjRel); }
@Override public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); final String timeZone = filter.getCluster().getPlanner().getContext() .unwrap(CalciteConnectionConfig.class).timeZone(); final RexNode condition = replaceTimeUnits(rexBuilder, filter.getCondition(), timeZone); if (condition.equals(filter.getCondition())) { return; } final RelBuilder relBuilder = relBuilderFactory.create(filter.getCluster(), null); relBuilder.push(filter.getInput()) .filter(condition); call.transformTo(relBuilder.build()); } }
final RelNode input = filter.getInput(); final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); final RexNode pred = filter.getCondition(); pred.accept(inputFinder); final ImmutableBitSet inputFieldsUsed = inputFinder.inputBitSet.build(); final RexInputRef ref = RexInputRef.of(idx, filter.getRowType().getFieldList()); final Set<RexNode> originalExprs = mq.getExpressionLineage(filter, ref); if (originalExprs == null) {
ASTNode cond = where.getCondition().accept(new RexVisitor(schema)); hiveAST.where = ASTBuilder.where(cond); for (int pos : hiveAgg.getAggregateColumnsOrder()) { RexInputRef iRef = new RexInputRef(groupBy.getGroupSet().nth(pos), groupBy.getCluster().getTypeFactory().createSqlType(SqlTypeName.ANY)); b.add(iRef.accept(new RexVisitor(schema))); if (!hiveAgg.getAggregateColumnsOrder().contains(pos)) { RexInputRef iRef = new RexInputRef(groupBy.getGroupSet().nth(pos), groupBy.getCluster().getTypeFactory().createSqlType(SqlTypeName.ANY)); b.add(iRef.accept(new RexVisitor(schema))); ASTNode cond = having.getCondition().accept(new RexVisitor(schema)); hiveAST.having = ASTBuilder.having(cond); if (RexUtil.isNull(r) && r.getType().getSqlTypeName() != SqlTypeName.NULL) { ASTNode expr = r.accept(new RexVisitor(schema, r instanceof RexLiteral)); String alias = select.getRowType().getFieldNames().get(i++); ASTNode selectExpr = ASTBuilder.selectExpr(expr, alias); b.add(selectExpr); RexCall call = (RexCall) udtf.getCall(); for (RexNode r : call.getOperands()) { if (RexUtil.isNull(r) && r.getType().getSqlTypeName() != SqlTypeName.NULL) {
@Override public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final HiveScanDrel scan = call.rel(1); final RexBuilder rexBuilder = filter.getCluster().getRexBuilder(); final RexNode originalFilter = filter.getCondition(); RexNode filterThatCanBePushed = originalFilter.accept(new ORCFindRelevantFilters(rexBuilder)); if (filterThatCanBePushed == null) { return; ORCFindRelevantFilters.convertBooleanInputRefToFunctionCall(rexBuilder, filterThatCanBePushed); final ORCSearchArgumentGenerator sargGenerator = new ORCSearchArgumentGenerator(scan.getRowType().getFieldNames()); filterThatCanBePushed.accept(sargGenerator); final SearchArgument sarg = sargGenerator.get(); call.transformTo(filter.copy(filter.getTraitSet(), newScan, originalFilter)); } catch (Exception e) { logger.warn("Failed to push filter into ORC reader", e);
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); //final RelBuilder builder = call.builder(); //TODO: replace HiveSubQRemoveRelBuilder with calcite's once calcite 1.11.0 is released final HiveSubQRemoveRelBuilder builder = new HiveSubQRemoveRelBuilder(null, call.rel(0).getCluster(), null); final RexSubQuery e = RexUtil.SubQueryFinder.find(filter.getCondition()); assert e != null; final RelOptUtil.Logic logic = LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(filter.getCondition()), e); builder.push(filter.getInput()); final int fieldCount = builder.peek().getRowType().getFieldCount(); assert(filter instanceof HiveFilter); Set<RelNode> corrScalarQueries = filter.getCluster().getPlanner().getContext().unwrap(Set.class); boolean isCorrScalarQuery = corrScalarQueries.contains(e.rel); final RexNode target = apply(e, HiveFilter.getVariablesSet(e), logic, builder, 1, fieldCount, isCorrScalarQuery); final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target); builder.filter(shuttle.apply(filter.getCondition())); builder.project(fields(builder, filter.getRowType().getFieldCount())); call.transformTo(builder.build()); } };