/** * Reset the rewriter to the initial state. * * @return this rewriter for chaining. */ public OpRewriter reset() { result = OpSequence.create(); return this; }
protected Op sequence(Op current, Op newOp) { return OpSequence.create(current, newOp) ; }
@Override public Op effectiveOp() { OpSequence result = OpSequence.create(); for(Op elt : elements) { result.add(elt); } return result; }
@Override public Op make(ItemList list) { BuilderLib.checkLengthAtLeast(2, list, "Sequence") ; OpSequence op = OpSequence.create() ; addOps(op, list) ; return op ; } } ;
@Override public Op effectiveOp() { OpSequence result = OpSequence.create(); for(Op elt : elements) { result.add(elt); } return result; }
/** * Rewrite sequence elements */ @Override public void visit(final OpSequence opSequence) { if (LOG.isDebugEnabled()) { LOG.debug("Starting visiting OpSequence"); } addOp(rewriteOpN(opSequence, OpSequence.create())); }
public Op getApplicableViews(OpSequence op, RestrictionManagerImpl restrictions) { List<Op> members = op.getElements(); List<Op> newMembers = new ArrayList<Op>(members.size()); for(Op member : members) { Op newMember = _getApplicableViews(member, restrictions); newMembers.add(newMember); } Op result = OpSequence.create().copy(newMembers); return result; }
public static Op _replace(OpSequence op) { List<Op> members = op.getElements(); List<Op> newMembers = new ArrayList<Op>(members.size()); for(Op member : members) { Op newMember = replace(member); newMembers.add(newMember); } Op result = OpSequence.create().copy(newMembers); return result; }
static private Op flush(BasicPattern bp, Op op) { if ( bp == null || bp.isEmpty() ) return op; OpBGP opBGP = new OpBGP(bp); op = OpSequence.create(op, opBGP); return op; }
@Override public Op transform(OpJoin opJoin, Op left, Op right) { //OpDisjunction result = OpDisjunction.create(); OpSequence result = OpSequence.create(); add(result, left); add(result, right); return result; }
@Override public Op transform(OpJoin opJoin, Op left, Op right) { //OpDisjunction result = OpDisjunction.create(); OpSequence result = OpSequence.create(); add(result, left); add(result, right); return result; }
private static Op flush(BasicPattern pattern, Op op) { if ( pattern == null || pattern.isEmpty() ) { if ( op == null ) return OpTable.unit() ; return op ; } OpBGP opBGP = new OpBGP(pattern) ; return OpSequence.create(op, opBGP) ; }
public Op _optimize(OpSequence op, RestrictionManagerImpl cnf) { List<Op> members = op.getElements(); List<Op> newMembers = new ArrayList<Op>(members.size()); Set<Clause> intersection = new HashSet<Clause>(); for(Op member : members) { RestrictionManagerImpl restrictions = filterByVars(cnf, member); Op newMember = optimize(member, restrictions); newMembers.add(newMember); Set<Clause> tmp = Sets.intersection(restrictions.getCnf(), intersection); intersection = new HashSet<Clause>(tmp); } Set<Clause> remaining = Sets.difference(cnf.getCnf(), intersection); Op result = OpSequence.create().copy(newMembers); if(!remaining.isEmpty()) { //result = OpFilter.filter(cnfToExprList(remaining), result); result = OpFilterIndexed.filter(new RestrictionManagerImpl(new NestedNormalForm(remaining)), result); } return result; }
private static Op transformFilterSequence(ExprList exprs, Set<Var> varScope, OpSequence opSequence) { List<Op> ops = opSequence.getElements(); // Any filters that depend on no variables. Op op = insertAnyFilter(exprs, varScope, null); for ( Op seqElt : ops ) { // Process the sequence element. This may insert filters (sequence // or BGP) seqElt = transform( exprs, varScope, seqElt ); // Merge into sequence. op = OpSequence.create( op, seqElt ); // Place any filters now ready. op = insertAnyFilter( exprs, varScope, op ); } return op; }
private Placement placeSequence(ExprList exprsIn, OpSequence opSequence) { ExprList exprs = ExprList.copy(exprsIn) ; Set<Var> varScope = new HashSet<>() ; List<Op> ops = opSequence.getElements() ; Op op = null ; for ( Op op1 : ops ) { op = insertAnyFilter$( exprs, varScope, op ); Op seqElt = op1; Placement p = transform( exprs, seqElt ); if ( isChange(p) ) { exprs = p.unplaced; seqElt = p.op; } varScope.addAll( fixedVars( seqElt ) ); op = OpSequence.create( op, seqElt ); } return result(op, exprs) ; }
private static Placement placeBGP(ExprList exprsIn, BasicPattern pattern) { ExprList exprs = ExprList.copy(exprsIn) ; Set<Var> patternVarsScope = new HashSet<>() ; // Any filters that depend on no variables. Op op = insertAnyFilter$(exprs, patternVarsScope, null) ; for (Triple triple : pattern) { OpBGP opBGP = getBGP(op) ; if ( opBGP == null ) { // Last thing was not a BGP (so it likely to be a filter) // Need to pass the results from that into the next triple. opBGP = new OpBGP() ; op = OpSequence.create(op, opBGP) ; } opBGP.getPattern().add(triple) ; // Update variables in scope. VarUtils.addVarsFromTriple(patternVarsScope, triple) ; op = insertAnyFilter$(exprs, patternVarsScope, op) ; } return result(op, exprs) ; }
/** Convert any paths of exactly one predicate to a triple pattern */ public static Op pathToTriples(PathBlock pattern) { BasicPattern bp = null; Op op = null; for ( TriplePath tp : pattern ) { if ( tp.isTriple() ) { if ( bp == null ) bp = new BasicPattern(); bp.add(tp.asTriple()); continue; } // Path form. op = flush(bp, op); bp = null; OpPath opPath2 = new OpPath(tp); op = OpSequence.create(op, opPath2); continue; } // End. Finish off any outstanding BGP. op = flush(bp, op); return op; }
private static Placement placeQuadPattern(ExprList exprsIn, Node graphNode, BasicPattern pattern) { ExprList exprs = ExprList.copy(exprsIn) ; Set<Var> patternVarsScope = new HashSet<>() ; // Any filters that depend on no variables. Op op = insertAnyFilter$(exprs, patternVarsScope, null) ; if ( Var.isVar(graphNode) ) { // Add in the graph node of the quad block. VarUtils.addVar(patternVarsScope, Var.alloc(graphNode)) ; } for (Triple triple : pattern) { OpQuadPattern opQuad = getQuads(op) ; if ( opQuad == null ) { opQuad = new OpQuadPattern(graphNode, new BasicPattern()) ; op = OpSequence.create(op, opQuad) ; } opQuad.getBasicPattern().add(triple) ; // Update variables in scope. VarUtils.addVarsFromTriple(patternVarsScope, triple) ; op = insertAnyFilter$(exprs, patternVarsScope, op) ; } return result(op, exprs) ; }
/** Convenience - convert to OpQuadPatterns which are more widely used (currently?) */ public Op convertOp() { if ( quads.size() == 0 ) return OpTable.empty() ; if ( quads.size() == 1 ) { Quad q = quads.get(0) ; BasicPattern bgp = new BasicPattern() ; bgp.add(q.asTriple()) ; return new OpQuadPattern(q.getGraph(), bgp) ; } List<OpQuadPattern> x = convert() ; OpSequence ops = OpSequence.create() ; for ( OpQuadPattern oqp : x ) ops.add(oqp); return ops ; }
private static Op transformFilterQuadPattern(ExprList exprs, Set<Var> patternVarsScope, Node graphNode, BasicPattern pattern) { // Any filters that depend on no variables. Op op = insertAnyFilter(exprs, patternVarsScope, null); if (Var.isVar(graphNode)) { // Add in the graph node of the quad block. // It's picked up after the first triple is processed. VarUtils.addVar(patternVarsScope, Var.alloc(graphNode)); } for (Triple triple : pattern) { OpQuadPattern opQuad = getQuads(op); if (opQuad == null) { opQuad = new OpQuadPattern(graphNode, new BasicPattern()); op = OpSequence.create(op, opQuad); } opQuad.getBasicPattern().add(triple); // Update variables in scope. VarUtils.addVarsFromTriple(patternVarsScope, triple); // Attempt to place any filters op = insertAnyFilter(exprs, patternVarsScope, op); } return op; }