private static List<Filter> getFilterChain(Set<Filter> filters) { final List<Filter> filterTopBottom = Lists.newArrayList(); Filter filterChainTop = null; Filter filterChainBottom = null; for (final Filter filter : filters) { if (filterChainTop == null) { filterChainTop = filter; filter.setParentNode(null); } else if (filterChainBottom == null) { filterChainBottom = filter; filterChainTop.setArg(filterChainBottom); } else { filterChainBottom.setArg(filter); filterChainBottom = filter; } } if (filterChainTop != null) { filterTopBottom.add(filterChainTop); } if (filterChainBottom != null) { filterTopBottom.add(filterChainBottom); } return filterTopBottom; }
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; }
} else if (filterChain.size() == 1) { newJoin = filterChain.get(0); ((Filter) newJoin).setArg(tempJoin); } else { newJoin = filterChain.get(0); filterChain.get(1).setArg(tempJoin); } else if (filterChain.size() == 1) { newJoin = filterChain.get(0); ((Filter) newJoin).setArg(tempJoin); } else { newJoin = filterChain.get(0); filterChain.get(1).setArg(tempJoin);
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; }
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; }
@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); }
protected void relocate(final Filter filter, final TupleExpr newFilterArg) { if (!filter.getArg().equals(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); } } }
/** * * This method moves the Filters of a specified {@link TupleExpr} to the top * of the TupleExpr. * * @param query * - query whose filters will be relocated * @return - TupleExpr with filters relocated to top */ public static TupleExpr moveFiltersToTop(TupleExpr query) { ProjectionAndFilterGatherer fg = new ProjectionAndFilterGatherer(); query.visit(fg); List<ValueExpr> filterCond = new ArrayList<>(fg.filterCond); Projection projection = fg.projection; if (filterCond.size() == 0) { return query; } Filter first = new Filter(); first.setCondition(filterCond.remove(0)); Filter current = first; for (ValueExpr cond : filterCond) { Filter filter = new Filter(null, cond); current.setArg(filter); current = filter; } TupleExpr te = projection.getArg(); projection.setArg(first); current.setArg(te); return query; }
private TupleExpr buildTuple(final List<QueryModelNode> nodes, final List<Filter> filters, final Projection projection) { final Projection proj = projection.clone(); Join join = null; join = new Join((TupleExpr) nodes.get(0).clone(), (TupleExpr) nodes.get(1).clone()); for (int i = 2; i < nodes.size(); i++) { join = new Join(join, (TupleExpr) nodes.get(i).clone()); } if (filters.size() == 0) { proj.setArg(join); return proj; } else { TupleExpr queryPlan = join; for (final Filter f : filters) { final Filter filt = f.clone(); filt.setArg(queryPlan); queryPlan = filt; } proj.setArg(queryPlan); return proj; } }
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); } } }
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(Join node) { if (!compSet.contains(node.getRightArg())) { // looks for placed to position filter node. if right node is // contained in index // and left node is statement pattern node contained in index or // is a join, place // filter above join. if (node.getLeftArg() instanceof Join || !compSet.contains(node.getLeftArg())) { QueryModelNode pNode = node.getParentNode(); ((Filter) filter).setArg(node); pNode.replaceChildNode(node, filter); filterPlaced = true; return; } // otherwise place filter below join and above right arg else { ((Filter) filter).setArg(node.getRightArg()); node.replaceChildNode(node.getRightArg(), filter); filterPlaced = true; return; } } else if (node.getLeftArg() instanceof StatementPattern && !compSet.contains(node.getLeftArg())) { ((Filter) filter).setArg(node.getLeftArg()); node.replaceChildNode(node.getLeftArg(), filter); filterPlaced = true; return; } else { super.meet(node); } }
@Override public void meet(Filter node) { if (replacement == null) { replaceNode(node, node.getArg()); } else if (replacement instanceof ValueExpr) { assert former == node.getCondition(); node.setCondition((ValueExpr)replacement); } else { assert former == node.getArg(); node.setArg((TupleExpr)replacement); } }
/** * Converts a {@link Filter} to a SPARQL query containing only the SPARQL representation * of the Filter along with a Select clause that return all variables. The argument of the * Filter is replaced by a {@link SingletonSet} so that the body of the SPARQL query consists of only a * single Filter clause. * @param filter - Filter to be serialized * @return - SPARQL String containing a single Filter clause that represents the serialized Filter * @throws FilterParseException */ public static String serialize(Filter filter) throws FilterParseException { Filter clone = filter.clone(); clone.setArg(new SingletonSet()); try { return removeAngularBracketsFromNonUriFunctions(renderer.render(new ParsedTupleQuery(clone))); } catch (Exception e) { throw new FilterParseException("Unable to parse Filter.", e); } }
((Filter)arg).setArg(extension);