@Override public Set<Filter> getFilters() { Collection<Filter> filters = conditionMap.values(); Set<Filter> filterSet = new HashSet<>(); for (Filter filter : filters) { filterSet.add(filter.clone()); } return filterSet; }
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 JoinSegment<T> clone() { List<QueryModelNode> order = new ArrayList<>(); for(QueryModelNode node: orderedNodes) { order.add(node.clone()); } Set<QueryModelNode> unorder = Sets.newHashSet(order); Map<ValueExpr, Filter> map = new HashMap<>(); for(ValueExpr expr: conditionMap.keySet()) { map.put(expr.clone(), conditionMap.get(expr).clone()); } return new JoinSegment<T>(unorder, order, map); }
@Override public OptionalJoinSegment<T> clone() { List<QueryModelNode> order = new ArrayList<>(); for(QueryModelNode node: orderedNodes) { order.add(node.clone()); } Set<QueryModelNode> unorder = Sets.newHashSet(order); Map<ValueExpr, Filter> map = new HashMap<>(); for(ValueExpr expr: conditionMap.keySet()) { map.put(expr.clone(), conditionMap.get(expr).clone()); } return new OptionalJoinSegment<T>(unorder, order, map); }
/** * * @return - a TupleExprAndNodes object that consists of the the TupleExpr * representation of the List of QueryModelNodes and the nodes used * to build the TupleExpr. */ public TupleExprAndNodes getTupleAndNodes() { List<QueryModelNode> nodeCopy = new ArrayList<>(); Set<Filter> setCopy = new HashSet<>(); for (QueryModelNode q : queryNodes) { nodeCopy.add(q.clone()); } for (Filter f : filters) { setCopy.add(f.clone()); } TupleExpr te = buildQuery(nodeCopy, setCopy); return new TupleExprAndNodes(te, nodeCopy, setCopy); }
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; } }
@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); } } }
/** * 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); } }