private static Pair<List<Pair<Var, NodeValue>>, ExprList> preprocessFilterEquality(ExprList exprs) { List<Pair<Var, NodeValue>> exprsFilterEquality = new ArrayList<>(); ExprList exprsOther = new ExprList(); for (Expr e : exprs.getList()) { Pair<Var, NodeValue> p = preprocess(e); if (p != null) exprsFilterEquality.add(p); else exprsOther.add(e); } if (exprsFilterEquality.size() == 0) return null; return Pair.create(exprsFilterEquality, exprsOther); }
private Placement placeProject(ExprList exprs, OpProject input) { Collection<Var> varsProject = input.getVars() ; ExprList pushed = new ExprList() ; ExprList unpushed = new ExprList() ; for ( Expr expr : exprs ) { Set<Var> exprVars = expr.getVarsMentioned() ; if ( varsProject.containsAll(exprVars) ) pushed.add(expr); else unpushed.add(expr) ; } if ( pushed.isEmpty() ) return resultNoChange(input) ; // (filter (project ...)) ===> (project (filter ...)) return processSubOp1(pushed, unpushed, input) ; }
private Placement placePropertyFunctionProcedure(ExprList exprsIn, Set<Var> varScope, Op1 op) { ExprList exprListPlaceable = new ExprList() ; ExprList exprListRetain = new ExprList() ; for ( Expr expr : exprsIn ) { Set<Var> mentioned = expr.getVarsMentioned() ; if ( Collections.disjoint(varScope, mentioned) ) exprListPlaceable.add(expr); else exprListRetain.add(expr); } if ( ! exprListPlaceable.isEmpty() ) { Placement p = transform(exprListPlaceable, op.getSubOp()) ; if ( isNoChange(p) ) return resultNoChange(op); Op newOp = op.copy(p.op) ; p.unplaced.addAll(exprListRetain); return result(newOp, p.unplaced) ; } return resultNoChange(op); }
private ExprList collect(ExprList exprList) { if ( exprList == null ) return null ; List<Expr> x = collect(exprList.size()) ; boolean changed = false ; for ( int i = 0 ; i < x.size() ; i++ ) { if ( x.get(i) != exprList.get(i) ) { changed = true ; break ; } } if ( ! changed ) return exprList ; return new ExprList(x) ; }
/** * Not really an Expr but a container of exprs. creates an empty list. * * @return the empty expression list. */ public final ExprList list() { return new ExprList(); }
public static Op _replace(OpQuadPattern op) { ExprList filters = new ExprList(); BasicPattern triples = new BasicPattern(); Node graphNode = transform(op.getGraphNode(), true, generator, filters); List<Node> nodes = new ArrayList<Node>(); for(Triple triple : op.getBasicPattern().getList()) { for(Node node : tripleToList(triple)) { Node n = transform(node, false, generator, filters); nodes.add(n); } Triple t = listToTriple(nodes); triples.add(t); nodes.clear(); } Op result = new OpQuadPattern(graphNode, triples); if(!filters.isEmpty()) { result = OpFilter.filter(filters, result); } return result; }
/** * Visiting filters in SPARQL algebra. */ @Override public void visit(final OpFilter opFilter) { Traversal traversal; for (Expr expr : opFilter.getExprs().getList()) { if (expr != null) { traversal = __.where(WhereTraversalBuilder.transform(expr)); traversalList.add(traversal); } } }
/** Add expression - mutates an existing filter */ public static Op filter(Expr expr, Op op) { OpFilter f = ensureFilter(op) ; f.getExprs().add(expr) ; return f ; }
/** * a1 AND ... AND an * * null: FALSE * empty: TRUE * expressions otherwise * * @param exprs * @return */ public static Type getConjunctionType(ExprList exprs) { if(exprs == null) { return Type.FALSE; } else if(exprs.isEmpty()) { return Type.TRUE; } else { return Type.EXPRLIST; } }