@Override public Op transform(OpQuadPattern opQuadPattern) { // The internal representation is (graph, BGP) BasicPattern bgp2 = NodeTransformLib.transform(transform, opQuadPattern.getBasicPattern()); Node g2 = opQuadPattern.getGraphNode(); g2 = transform.apply(g2); if ( g2 == opQuadPattern.getGraphNode() && bgp2 == opQuadPattern.getBasicPattern() ) return super.transform(opQuadPattern); return new OpQuadPattern(g2, bgp2); }
public OpQuadBlock(OpQuadPattern quadPattern) { this.quads = quadPattern.getPattern() ; }
public QuadPattern getPattern() { initQuads() ; return quads ; }
@Override public Op transform(OpQuadPattern opQuadPattern) { BasicPattern bgp = opQuadPattern.getBasicPattern(); Node graphNode = opQuadPattern.getGraphNode(); Op result = OpUtils.toOpGraphTriples(graphNode, bgp); return result; } }
public QuadBlock(OpQuadPattern quadPattern) { super() ; this.addAll(quadPattern.getPattern().getList()) ; graphNode = quadPattern.getGraphNode() ; }
@Override public QueryIterator execute(OpQuadPattern opQuadPattern, QueryIterator input) { Node gn = opQuadPattern.getGraphNode() ; gn = decideGraphNode(gn, execCxt) ; if ( execCxt.getDataset() instanceof DatasetGraphTDB ) { DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ; Explain.explain("Execute", opQuadPattern.getPattern(), execCxt.getContext()) ; BasicPattern bgp = opQuadPattern.getBasicPattern() ; return SolverLib.execute(ds, gn, bgp, input, filter, execCxt) ; } // Maybe a TDB named graph inside a non-TDB dataset. Graph g = execCxt.getActiveGraph() ; if ( g instanceof GraphTDB ) { // Triples graph from TDB (which is the default graph of the dataset), // used a named graph in a composite dataset. BasicPattern bgp = opQuadPattern.getBasicPattern() ; Explain.explain("Execute", bgp, execCxt.getContext()) ; // Don't pass in G -- gn may be different. return SolverLib.execute(((GraphTDB)g).getDatasetGraphTDB(), gn, bgp, input, filter, execCxt) ; } Log.warn(this, "Non-DatasetGraphTDB passed to OpExecutorPlainTDB") ; return super.execute(opQuadPattern, input) ; }
@Override public Op0 copy() { return new OpQuadPattern(graphNode, triples) ; }
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) ; }
protected QueryIterator execute(OpQuadPattern quadPattern, QueryIterator input) { // Convert to BGP forms to execute in this graph-centric engine. if (quadPattern.isDefaultGraph() && execCxt.getActiveGraph() == execCxt.getDataset().getDefaultGraph()) { // Note we tested that the containing graph was the dataset's // default graph. // Easy case. OpBGP opBGP = new OpBGP(quadPattern.getBasicPattern()) ; return execute(opBGP, input) ; } // Not default graph - (graph .... ) OpBGP opBGP = new OpBGP(quadPattern.getBasicPattern()) ; OpGraph op = new OpGraph(quadPattern.getGraphNode(), opBGP) ; return execute(op, input) ; }
static Table evalQuadPattern(OpQuadPattern opQuad, Evaluator evaluator) if ( opQuad.isEmpty() ) return TableFactory.createUnit() ; BasicPattern pattern = opQuad.getBasicPattern() ; if ( ! opQuad.getGraphNode().isVariable() ) if ( ! opQuad.getGraphNode().isURI() ) { throw new ARQInternalErrorException("Not a URI or variable: "+opQuad.getGraphNode()) ;} Graph g = null ; if ( opQuad.isDefaultGraph() ) g = ds.getDefaultGraph() ; else g = ds.getGraph(opQuad.getGraphNode()) ; if ( g == null ) return new TableEmpty() ; Var gVar = Var.alloc(opQuad.getGraphNode()) ;
public static MappedConcept<DatasetGraph> query2(Query query, Var partitionVar) { Assert.isTrue(query.isConstructType()); Template template = query.getConstructTemplate(); BasicPattern bgp = template.getBGP(); BasicPattern newBgp = allocVarsForBlankNodes(bgp); //org.aksw.jena_sparql_api.utils.VarUtils. // Allocate a fresh var for the graph Var g = Var.alloc("_g_"); //Element e = new Element Element tmp = new ElementTriplesBlock(newBgp); Element newElement = new ElementNamedGraph(g, tmp); OpQuadPattern tmpOp = new OpQuadPattern(g, newBgp); QuadPattern quadPattern = tmpOp.getPattern(); Concept concept = new Concept(newElement, partitionVar); Agg<DatasetGraph> agg = AggDatasetGraph.create(quadPattern); MappedConcept<DatasetGraph> result = MappedConcept.create(concept, agg); return result; }
@Override public Op transform(OpQuadPattern quadPattern) { if ( quadPattern.isDefaultGraph() || quadPattern.isUnionGraph() ) { OpBGP opBGP = new OpBGP(quadPattern.getBasicPattern()) ; return union(opBGP) ; } // Leave alone. // if ( quadPattern.isExplicitDefaultGraph() ) {} return super.transform(quadPattern) ; }
bgp = ((OpQuadPattern)op).getBasicPattern() ; } else if ( op instanceof OpBGP ) { bgp = ((OpBGP)op).getPattern() ;
protected QueryIterator execute(OpDatasetNames dsNames, QueryIterator input) { if (false) { OpGraph op = new OpGraph(dsNames.getGraphNode(), new OpBGP()) ; return execute(op, input) ; } throw new ARQNotImplemented("execute/OpDatasetNames") ; }
@Override public void visit(OpQuadPattern quadPattern) { addVars(defines, quadPattern.getGraphNode(), quadPattern.getBasicPattern()); }
@Override public QueryIterator execute(OpQuadPattern opQuadPattern, QueryIterator input) { Node gn = opQuadPattern.getGraphNode() ; gn = decideGraphNode(gn, execCxt) ; if ( execCxt.getDataset() instanceof DatasetGraphTDB ) { DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ; Explain.explain("Execute", opQuadPattern.getPattern(), execCxt.getContext()) ; BasicPattern bgp = opQuadPattern.getBasicPattern() ; return SolverLib.execute(ds, gn, bgp, input, filter, execCxt) ; } // Maybe a TDB named graph inside a non-TDB dataset. Graph g = execCxt.getActiveGraph() ; if ( g instanceof GraphTDB ) { // Triples graph from TDB (which is the default graph of the dataset), // used a named graph in a composite dataset. BasicPattern bgp = opQuadPattern.getBasicPattern() ; Explain.explain("Execute", bgp, execCxt.getContext()) ; // Don't pass in G -- gn may be different. return SolverLib.execute(((GraphTDB)g).getDSG(), gn, bgp, input, filter, execCxt) ; } Log.warn(this, "Non-DatasetGraphTDB passed to OpExecutorPlainTDB") ; return super.execute(opQuadPattern, input) ; }
@Override public Op transform(OpBGP opBGP) { //System.out.print("transform(OpBGP) : "+getNode()+"\n"+opBGP) ; return new OpQuadPattern(getNode(), opBGP.getPattern()) ; }
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; }
bgp = ((OpQuadPattern)op).getBasicPattern() ; } else if ( op instanceof OpBGP ) { bgp = ((OpBGP)op).getPattern() ;
@Override public Op transform(OpQuadPattern opQuadPattern) { if ( opQuadPattern.getGraphNode().equals(oldGraphName) ) opQuadPattern = new OpQuadPattern(newGraphName, opQuadPattern.getBasicPattern()) ; return super.transform(opQuadPattern) ; } }