/** Create a OpFilter with the expressions and subOp. * If subOp is a filter, combine expressions (de-layer). */ public static OpFilter filterAlways(ExprList exprs, Op subOp) { OpFilter f = ensureFilter(subOp) ; f.getExprs().addAll(exprs) ; return f ; }
@Override public Op transform(OpFilter opFilter, Op subOp) { ExprList exprList = opFilter.getExprs() ; exprList = ExprList.splitConjunction(exprList) ; // Do not use -- OpFilter.filter(exprList, subOp) -- it compresses (filter (..) (filter )) return OpFilter.filterDirect(exprList, subOp) ; }
private Placement placeFilter(ExprList exprs, OpFilter input) { // If input.getSubOp is itself a filter, it has already been // processed because the Transform is applied bottom-up. // We must not let the filter's expressions go back as "unplaced" // as they are scoped to the input and if "unplaced" are available // out of that scope. Op op = input.getSubOp() ; ExprList exprsInner = input.getExprs() ; ExprList exprsOuter = exprs ; // Outer Placement p = transform(exprsOuter, input.getSubOp()) ; if ( isChange(p) ) { op = p.op ; exprsOuter = p.unplaced ; } // Put inner round the modified Op. // If op is also a filter, a single filter is created with // exprsInner now after placed filters. // ("after" means later in the exprList of the filter). Op f = OpFilter.filterBy(exprsInner, op) ; return new Placement(f, exprsOuter) ; }
/** * 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); } } }
/** Compress multiple filters: (filter (filter (filter op)))) into one (filter op) */ public static OpFilter tidy(OpFilter base) { ExprList exprs = new ExprList() ; Op op = base ; while (op instanceof OpFilter) { OpFilter f = (OpFilter)op ; exprs.addAll(f.getExprs()) ; op = f.getSubOp() ; } return new OpFilter(exprs, op) ; }
@Override public void visit(OpFilter opFilter) { Op subOp = null ; if ( opFilter.getSubOp() != null ) subOp = pop(opStack) ; ExprList ex = opFilter.getExprs() ; if ( ex == null || ex.isEmpty() ) { // No expressions. // Doesn't normally happen but this code is safe in these cases. push(opStack, opFilter.apply(opTransform, subOp)) ; return ; } // ex2 is the same length as ex. ExprList ex2 = collect(ex) ; OpFilter f = opFilter ; if ( ex != ex2 || opFilter.getSubOp() != subOp ) { f = OpFilter.filterAlways(ex2, subOp) ; // If we removed a layer of filter, then subOp needs changing // else f-subOp is subOp anyway. subOp = f.getSubOp() ; } push(opStack, f.apply(opTransform, subOp)) ; }
/** @deprecated Renamed as {#link filterBy} */ @Deprecated public static Op filter(ExprList exprs, Op op) { return filterBy(exprs, op) ; }
@Override public void visit(OpFilter op) { Op subOp = op.getSubOp(); // TODO Auto-generated method stub //super.visit(opFilter); }
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; } }
@Override public Op make(ItemList list) { BuilderLib.checkLength(3, list, "Malformed filter") ; Item itemExpr = list.get(1) ; Item itemOp = list.get(2) ; Op op = build(itemOp.getList()) ; ExprList exprList = BuilderExpr.buildExprOrExprList(itemExpr) ; return OpFilter.filterDirect(exprList, op) ; } } ;
@Override public void visit(OpFilter opFilter) { opFilter.getExprs().prepareExprs(context) ; }
@Override public Op effectiveOp() { return OpFilter.filterBy(restrictions.getExprs(), subOp); }
/** Add expression - mutates an existing filter */ public static Op filter(Expr expr, Op op) { OpFilter f = ensureFilter(op) ; f.getExprs().add(expr) ; return f ; }
@Override public void visit(OpFilter op) { Op subOp = op.getSubOp(); // TODO Auto-generated method stub //super.visit(opFilter); }
/** 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; }