/** * If the filter list passed in is non-empty, creates a FilterRel on top of * the existing RelNode; otherwise, just returns the RelNode * * @param rexBuilder rex builder * @param rel the RelNode that the filter will be put on top of * @param filters list of filters * * @return new RelNode or existing one if no filters */ private RelNode createFilterOnRel( RexBuilder rexBuilder, RelNode rel, List<RexNode> filters) { RelNode newRel; if (filters.size() == 0) { newRel = rel; } else { RexNode andFilters = RexUtil.andRexNodeList(rexBuilder, filters); newRel = CalcRel.createFilter(rel, andFilters); } return newRel; } }
/** * AND's two predicates together, either of which may be null, removing * redundant filters. * * @param rexBuilder rexBuilder used to construct AND'd RexNode * @param pred1 first predicate * @param pred2 second predicate * * @return AND'd predicate or individual predicates if one is null */ public static RexNode unionPreds( RexBuilder rexBuilder, RexNode pred1, RexNode pred2) { final List<RexNode> unionList = new ArrayList<RexNode>(); final Set<String> strings = new HashSet<String>(); for (RexNode rex : RelOptUtil.conjunctions(pred1)) { if (strings.add(rex.toString())) { unionList.add(rex); } } for (RexNode rex2 : RelOptUtil.conjunctions(pred2)) { if (strings.add(rex2.toString())) { unionList.add(rex2); } } return RexUtil.andRexNodeList(rexBuilder, unionList); }
public static RexNode splitCorrelatedFilterCondition( FilterRel filterRel, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess) { List<RexNode> nonEquiList = new ArrayList<RexNode>(); splitCorrelatedFilterCondition( filterRel, filterRel.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList, extractCorrelatedFieldAccess); // Convert the remainders into a list that are AND'ed together. switch (nonEquiList.size()) { case 0: return null; case 1: return nonEquiList.get(0); default: return RexUtil.andRexNodeList( filterRel.getCluster().getRexBuilder(), nonEquiList); } }
return RexUtil.andRexNodeList(rexBuilder, minusList);
public static RexNode splitCorrelatedFilterCondition( FilterRel filterRel, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys) { List<RexNode> nonEquiList = new ArrayList<RexNode>(); splitCorrelatedFilterCondition( filterRel, filterRel.getCondition(), joinKeys, correlatedJoinKeys, nonEquiList); // Convert the remainders into a list that are AND'ed together. switch (nonEquiList.size()) { case 0: return null; case 1: return nonEquiList.get(0); default: return RexUtil.andRexNodeList( filterRel.getCluster().getRexBuilder(), nonEquiList); } }
public Double getSelectivity(AggregateRelBase rel, RexNode predicate) { List<RexNode> notPushable = new ArrayList<RexNode>(); List<RexNode> pushable = new ArrayList<RexNode>(); RelOptUtil.splitFilters( rel.getGroupCount(), predicate, pushable, notPushable); RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); RexNode childPred = RexUtil.andRexNodeList(rexBuilder, pushable); Double selectivity = RelMetadataQuery.getSelectivity( rel.getChild(), childPred); if (selectivity == null) { return null; } else { RexNode pred = RexUtil.andRexNodeList(rexBuilder, notPushable); return selectivity * RelMdUtil.guessSelectivity(pred); } }
private RexNode createCondition( RexBuilder builder, RelNode left, List<Integer> leftKeys, RelNode right, List<Integer> rightKeys ) { final List<RelDataType> leftTypes = RelOptUtil.getFieldTypeList( left.getRowType() ); final List<RelDataType> rightTypes = RelOptUtil.getFieldTypeList( right.getRowType() ); final List<RexNode> exprs = new ArrayList<RexNode>(); for( Pair<Integer, Integer> pair : Pair.zip( leftKeys, rightKeys ) ) exprs.add( builder.makeCall( SqlStdOperatorTable.equalsOperator, builder.makeInputRef( leftTypes.get( pair.left ), pair.left ), builder.makeInputRef( rightTypes.get( pair.right ), pair.right + leftTypes.size() ) ) ); return RexUtil.andRexNodeList( builder, exprs ); } }
return RexUtil.andRexNodeList(rexBuilder, joinConditions);
public Double getSelectivity(ProjectRelBase rel, RexNode predicate) { List<RexNode> notPushable = new ArrayList<RexNode>(); List<RexNode> pushable = new ArrayList<RexNode>(); RelOptUtil.splitFilters( rel.getRowType().getFieldCount(), predicate, pushable, notPushable); RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); RexNode childPred = RexUtil.andRexNodeList(rexBuilder, pushable); RexNode modifiedPred; if (childPred == null) { modifiedPred = null; } else { modifiedPred = RelOptUtil.pushFilterPastProject(childPred, rel); } Double selectivity = RelMetadataQuery.getSelectivity( rel.getChild(), modifiedPred); if (selectivity == null) { return null; } else { RexNode pred = RexUtil.andRexNodeList(rexBuilder, notPushable); return selectivity * RelMdUtil.guessSelectivity(pred); } }
notPushable); RexNode childPreds = RexUtil.andRexNodeList( rel.getCluster().getRexBuilder(), pushable); } else { RexNode preds = RexUtil.andRexNodeList( rel.getCluster().getRexBuilder(), notPushable);
return residualList.get(0); default: return RexUtil.andRexNodeList( left.getCluster().getRexBuilder(), residualList);
leftPred = RexUtil.andRexNodeList(rexBuilder, leftFilters); rightPred = RexUtil.andRexNodeList(rexBuilder, rightFilters);
RexNode childPred = RexUtil.andRexNodeList(rexBuilder, pushable); RexNode modifiedPred; if (childPred == null) { } else if (!notPushable.isEmpty()) { RexNode preds = RexUtil.andRexNodeList( rel.getCluster().getRexBuilder(), notPushable);
RexUtil.andRexNodeList( cluster.getRexBuilder(), conditions);
return nonEquiList.get(0); default: return RexUtil.andRexNodeList( leftRel.getCluster().getRexBuilder(), nonEquiList);
joinFilter = RexUtil.andRexNodeList(rexBuilder, joinFilters);