@Override public void meet(Filter node) { filterCond.add(node.getCondition()); node.replaceWith(node.getArg()); }
@Override public void meet(Filter filter) { super.meet(filter); List<ValueExpr> conjunctiveConstraints = new ArrayList<ValueExpr>(16); getConjunctiveConstraints(filter.getCondition(), conjunctiveConstraints); TupleExpr filterArg = filter.getArg(); for (int i = conjunctiveConstraints.size() - 1; i >= 1; i--) { Filter newFilter = new Filter(filterArg, conjunctiveConstraints.get(i)); filterArg = newFilter; } filter.setCondition(conjunctiveConstraints.get(0)); filter.setArg(filterArg); }
@Override public void meet(Filter filterNode) throws Exception { filterNode.visitChildren(this); if (filterNode.getArg() instanceof AggregationPipelineQueryNode && filterNode.getParentNode() != null) { AggregationPipelineQueryNode pipelineNode = (AggregationPipelineQueryNode) filterNode.getArg(); if (pipelineNode.filter(filterNode.getCondition())) { filterNode.replaceWith(pipelineNode); } } } }
private TupleExpr filteredTuple(TupleExpr theExpr) { TupleExpr aExpr = theExpr; for (ValueExpr aValEx : mFilters) { Filter aFilter = new Filter(); aFilter.setCondition(aValEx); aFilter.setArg(aExpr); aExpr = aFilter; } return aExpr; }
@Override public void meet(EmptySet node) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } }
@Nullable public static TupleExpr explodeFilters(@Nullable TupleExpr expr) { if (expr == null) { return null; } expr = expr.clone(); expr.setParentNode(null); final List<Filter> filters = extractNodes(expr, Filter.class, (final Filter filter) -> { return filter.getCondition() instanceof And; }, null); if (filters.isEmpty()) { return expr; } for (final Filter filter : filters) { TupleExpr arg = filter.getArg(); for (final ValueExpr condition : extractNodes(filter.getCondition(), ValueExpr.class, e -> !(e instanceof And), e -> e instanceof And)) { arg = new Filter(arg, condition); } expr = (TupleExpr) replaceNode(expr, filter, arg); } return expr; }
@Override public void meet(Intersection node) { Filter clone = new Filter(); clone.setCondition(filter.getCondition().clone()); relocate(filter, node.getLeftArg()); relocate(clone, node.getRightArg()); FilterRelocator.relocate(filter); FilterRelocator.relocate(clone); }
@Override public void meet(Filter node) { spFilterSet.add(node.getCondition()); node.getArg().visit(this); }
@Override public void meet(final Filter node) throws Exception { super.meet(node); final ValueExpr condition = node.getCondition(); final TupleExpr arg = node.getArg(); if (!(arg instanceof Join)) { return; } final Join join = (Join) arg; final TupleExpr leftArg = join.getLeftArg(); final TupleExpr rightArg = join.getRightArg(); if (leftArg instanceof StatementPattern && rightArg instanceof StatementPattern) { final Filter left = new Filter(leftArg, condition); final Filter right = new Filter(rightArg, condition); node.replaceWith(new Join(left, right)); } } }
protected void relocate(Filter filter, TupleExpr newFilterArg) { if (filter.getArg() != newFilterArg) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } // Insert filter at the new location newFilterArg.replaceWith(filter); filter.setArg(newFilterArg); } } }
@Override public void meet(Filter node) { Set<QueryModelNode> eSet = getQNodes(node); if (eSet.containsAll(sSet)) { if (eSet.equals(sSet)) { node.replaceWith(set); indexPlaced = true; return; } else { node.getArg().visit(this); } } }
@Override public void meet(Filter node) throws RuntimeException { super.meet(node); if (node.getArg() instanceof SelectQuery) { SelectQuery query = (SelectQuery)node.getArg(); ValueExpr condition = null; for (ValueExpr expr : flatten(node.getCondition())) { try { query.addFilter(sql.createBooleanExpr(expr)); } catch (UnsupportedRdbmsOperatorException e) { if (condition == null) { condition = expr; } else { condition = new And(condition, expr); } } } if (condition == null) { node.replaceWith(node.getArg()); } else { node.setCondition(condition); } } }
public FilterCursor( CloseableIteration<BindingSet, QueryEvaluationException> result, ValueExpr condition, final Set<String> scopeBindingNames, EvaluationStrategy strategy) throws QueryEvaluationException { super(new Filter(new EmptySet() { @Override public Set<String> getBindingNames() { return scopeBindingNames; } }, condition), result, strategy); }
/** * Make a {@link FilterEvaluator} that processes the logic of a {@link Filter}. * * @param filter - Defines the Filter that will be processed. (not null) * @return The {@link FilterEvaluator} for the provided {@link Filter}. */ public static FilterEvaluator make(final Filter filter) { requireNonNull(filter); final ValueExpr condition = filter.getCondition(); return new FilterEvaluator(condition); }
@Override public void meet(Filter node) { Set<QueryModelNode> eSet = getQNodes(node); Set<QueryModelNode> compSet = Sets.difference(eSet, sSet); // if index contains filter node and it hasn't already been moved, // move it down // query tree just above position of statement pattern nodes found // in both query tree // and index (assuming that SPBubbleDownVisitor has already been // called) if (sSet.contains(node.getCondition()) && !bubbledFilters.contains(node.getCondition())) { FilterBubbleDownVisitor fbdv = new FilterBubbleDownVisitor(node.clone(), compSet); node.visit(fbdv); bubbledFilters.add(node.getCondition()); // checks if filter correctly placed, and if it has been, // removes old copy of filter if (fbdv.filterPlaced()) { QueryModelNode pNode = node.getParentNode(); TupleExpr cNode = node.getArg(); pNode.replaceChildNode(node, cNode); super.meetNode(pNode); } super.meet(node); } else { super.meet(node); } } }
@Override public void meet(final Filter node) { filterSet.add(node); node.getArg().visit(this); }
if (theFilter.getArg() != null) { theFilter.getArg().visit(this); final boolean aNeedsNewScope = theFilter.getParentNode() != null && (theFilter.getParentNode() instanceof Join || theFilter.getParentNode() instanceof LeftJoin); String aFilter = renderValueExpr(theFilter.getCondition()); if (theFilter.getCondition() instanceof ValueConstant || theFilter.getCondition() instanceof Var) {
@Override public Filter clone() { Filter clone = (Filter)super.clone(); clone.setCondition(getCondition().clone()); return clone; } }
private List<TupleExpr> getFilterChain(List<TupleExpr> joinArgs) { List<TupleExpr> filterTopBottom = Lists.newArrayList(); TupleExpr filterChainTop = null; TupleExpr filterChainBottom = null; for(int i = 0; i < joinArgs.size(); i++) { if(joinArgs.get(i) instanceof Filter) { if(filterChainTop == null) { filterChainTop = joinArgs.remove(i); i--; } else if(filterChainBottom == null){ filterChainBottom = joinArgs.remove(i); ((Filter)filterChainTop).setArg(filterChainBottom); i--; } else { ((Filter)filterChainBottom).setArg(joinArgs.remove(i)); filterChainBottom = ((Filter)filterChainBottom).getArg(); i--; } } } if(filterChainTop != null) { filterTopBottom.add(filterChainTop); } if(filterChainBottom != null) { filterTopBottom.add(filterChainBottom); } return filterTopBottom; }
private static List<TupleExpr> getFilterChain(List<Filter> filters) { List<TupleExpr> filterTopBottom = Lists.newArrayList(); Filter filterChainTop = null; Filter filterChainBottom = null; for (Filter filter : filters) { if (filterChainTop == null) { filterChainTop = filter.clone(); } else if (filterChainBottom == null) { filterChainBottom = filter.clone(); filterChainTop.setArg(filterChainBottom); } else { Filter newFilter = filter.clone(); filterChainBottom.setArg(newFilter); filterChainBottom = newFilter; } } if (filterChainTop != null) { filterTopBottom.add(filterChainTop); } if (filterChainBottom != null) { filterTopBottom.add(filterChainBottom); } return filterTopBottom; }