public static Op surroundWithFilterIfNeccessary(Op op, Set<Set<Expr>> cnf) { if(cnf.isEmpty()) { return op; } else { ExprList exprs = cnfToExprList(cnf); Op result = OpFilter.filter(exprs, op); return result; } }
private static Op buildFilter(ExprList exprs, Op op) { if ( exprs == null || exprs.isEmpty() ) return op ; for ( Expr expr : exprs ) { if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; } return op ; } }
/** Place expressions around an Op */ private static Op buildFilter(ExprList exprs, Op op) { if (exprs.isEmpty()) return op; for (Iterator<Expr> iter = exprs.iterator(); iter.hasNext();) { Expr expr = iter.next(); if (op == null) op = OpTable.unit(); op = OpFilter.filter(expr, op); iter.remove(); } return op; } }
/** For any expression now in scope, wrap the op with a filter */ private static Op insertAnyFilter(ExprList exprs, Set<Var> patternVarsScope, Op op) { for (Iterator<Expr> iter = exprs.iterator(); iter.hasNext();) { Expr expr = iter.next(); // Cache Set<Var> exprVars = expr.getVarsMentioned(); if (patternVarsScope.containsAll(exprVars)) { if (op == null) op = OpTable.unit(); op = OpFilter.filter(expr, op); iter.remove(); } } return op; }
/** For any expression now in scope, wrap the op with a filter. */ private static Op insertAnyFilter$(ExprList unplacedExprs, Collection<Var> patternVarsScope, Op op) { for (Iterator<Expr> iter = unplacedExprs.iterator(); iter.hasNext();) { Expr expr = iter.next() ; // Cache Set<Var> exprVars = expr.getVarsMentioned() ; if ( patternVarsScope.containsAll(exprVars) ) { if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; iter.remove() ; } } return op ; }
protected Op compileElementExists(Op current, ElementExists elt2) { Op op = compile(elt2.getElement()) ; // "compile", not "compileElement" -- do simpliifcation Expr expr = new E_Exists(elt2, op) ; return OpFilter.filter(expr, current) ; }
public static Op _replace(OpFilter op) { return OpFilter.filter(op.getExprs(), replace(op.getSubOp())); }
protected Op compileElementNotExists(Op current, ElementNotExists elt2) { Op op = compile(elt2.getElement()) ; // "compile", not "compileElement" -- do simpliifcation Expr expr = new E_Exists(elt2, op) ; expr = new E_LogicalNot(expr) ; return OpFilter.filter(expr, current) ; }
eOther = new E_LogicalOr(eOther, e) ; Op opOther = OpFilter.filter(eOther, subOp) ; op = OpDisjunction.create(op, opOther) ;
public static Op _optimize(OpJoin op, Set<Set<Expr>> cnf) { Set<Set<Expr>> leftCnf = filterByVars(cnf, op.getLeft()); Set<Set<Expr>> rightCnf = filterByVars(cnf, op.getLeft()); Set<Set<Expr>> union = Sets.union(leftCnf, rightCnf); Set<Set<Expr>> remaining = Sets.difference(cnf, union); Op result = OpJoin.create(optimize(op.getLeft(), leftCnf), optimize(op.getRight(), rightCnf)); if(!remaining.isEmpty()) { result = OpFilter.filter(cnfToExprList(remaining), result); } return result; }
protected Op compileElementGroup(ElementGroup groupElt) { Pair<List<Expr>, List<Element>> pair = prepareGroup(groupElt) ; List<Expr> filters = pair.getLeft() ; List<Element> groupElts = pair.getRight() ; // Compile the consolidated group elements. // "current" is the completed part only - there may be thing pushed into the accumulator. Op current = OpTable.unit() ; Deque<Op> acc = new ArrayDeque<>() ; for ( Element elt : groupElts ) { if ( elt != null ) { current = compileOneInGroup( elt, current, acc ); } } // Deal with any remaining ops. //current = joinOpAcc(current, acc) ; if ( filters != null ) { // Put filters round the group. for ( Expr expr : filters ) current = OpFilter.filter(expr, current) ; } return current ; }
public Op toOp(Op result) { if(filter.getExpr().equals(NodeValue.TRUE)) { result = OpFilter.filter(filter.getExpr(), result); } result = OpUtils.applyExtendProject(result, preDistinctVarDefs); if(postDistinctVarDefs != null) { result = OpDistinct.create(result); result = OpUtils.applyExtendProject(result, postDistinctVarDefs); } return result; }
public Op toOp(Op result) { if(filter.getExpr().equals(NodeValue.TRUE)) { result = OpFilter.filter(filter.getExpr(), result); } result = OpUtils.applyExtendProject(result, preDistinctVarDefs); if(postDistinctVarDefs != null) { result = OpDistinct.create(result); result = OpUtils.applyExtendProject(result, postDistinctVarDefs); } return result; }
public Op toOp(Op result) { if(filter.getExpr().equals(NodeValue.TRUE)) { result = OpFilter.filter(filter.getExpr(), result); } result = OpUtils.applyExtendProject(result, preDistinctVarDefs); if(postDistinctVarDefs != null) { result = OpDistinct.create(result); result = OpUtils.applyExtendProject(result, postDistinctVarDefs); } return result; }
public Op toOp(Op result) { if(filter.getExpr().equals(NodeValue.TRUE)) { result = OpFilter.filter(filter.getExpr(), result); } result = OpUtils.applyExtendProject(result, preDistinctVarDefs); if(postDistinctVarDefs != null) { result = OpDistinct.create(result); result = OpUtils.applyExtendProject(result, postDistinctVarDefs); } return result; }
securityEvaluator, variables, newBGP); Op filter = OpFilter.filter(secFunc, new OpBGP(BasicPattern.wrap(newBGP)));
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; }
opFilter = (OpFilter)op; } else { opFilter = (OpFilter)OpFilter.filter(NodeValue.TRUE, op);
opFilter = (OpFilter)op; } else { opFilter = (OpFilter)OpFilter.filter(NodeValue.TRUE, op);
return OpFilter.filter(f.getExpr(), current) ;