public BasicPattern getBGP() { if (this.bgp != null){ return this.bgp; } BasicPattern bgp = new BasicPattern(); for(Quad q: qp.getQuads()){ if (Quad.defaultGraphNodeGenerated.equals(q.getGraph())) bgp.add(q.asTriple()); } return bgp; } public List<Triple> getTriples()
/** * Visiting triple patterns in SPARQL algebra. */ @Override public void visit(final OpBGP opBGP) { if(optionalFlag) { opBGP.getPattern().getList().forEach(triple -> optionalTraversals.add(TraversalBuilder.transform(triple))); opBGP.getPattern().getList().forEach(triple -> optionalVariable.add(triple.getObject().toString())); } else opBGP.getPattern().getList().forEach(triple -> traversalList.add(TraversalBuilder.transform(triple))); }
/** Return a new basic pattern with the same triples as the input, * but ordered as per the index list of this reorder processor. */ @Override public BasicPattern reorder(BasicPattern bgp) { if ( indexes.length != bgp.size() ) { String str = String.format("Expected size = %d : actual basic pattern size = %d", indexes.length, bgp.size()) ; Log.error(this, str) ; throw new ARQException(str) ; } BasicPattern bgp2 = new BasicPattern() ; for ( int idx : indexes ) { Triple t = bgp.get( idx ); bgp2.add( t ); } return bgp2 ; }
private static BasicPattern merge(BasicPattern p1, BasicPattern p2) { if ( p1 == null || p2 == null ) return null ; BasicPattern p = new BasicPattern() ; p.addAll(p1) ; p.addAll(p2) ; return p ; }
public boolean equivalent(OpBGP opBGP) { BasicPattern bgp = opBGP.getPattern() ; if ( bgp.size() != 1 ) return false ; Triple t = bgp.get(0) ; return triple.equals(t) ; }
/** * Creates a set of triples by omitting the graph node of the quads * * @param quadPattern * @return */ public static BasicPattern toBasicPattern(QuadPattern quadPattern) { BasicPattern result = new BasicPattern(); for(Quad quad : quadPattern) { Triple triple = quad.asTriple(); result.add(triple); } return result; }
private void initVars() { _vars = new LinkedHashSet<>(); for (int i = 0; i < _pattern.size(); i++) { final Triple t = _pattern.get(i); if (ARQParser.isDistinguishedVariable(t.getSubject())) _vars.add(t.getSubject().getName()); if (t.getPredicate().isVariable()) _vars.add(t.getPredicate().getName()); if (ARQParser.isDistinguishedVariable(t.getObject())) _vars.add(t.getObject().getName()); } }
public static Query createQueryTriple(Triple m) { Query query = new Query(); query.setQueryConstructType(); /* Node s = m.getMatchSubject(); Node p = m.getMatchPredicate(); Node o = m.getMatchObject(); */ Node s = m.getSubject(); Node p = m.getPredicate(); Node o = m.getObject(); s = s == null || s.equals(Node.ANY) ? Vars.s : s; p = p == null || p.equals(Node.ANY) ? Vars.p : p; o = o == null || o.equals(Node.ANY) ? Vars.o : o; Triple triple = new Triple(s, p, o); BasicPattern bgp = new BasicPattern(); bgp.add(triple); Template template = new Template(bgp); Element element = new ElementTriplesBlock(bgp); query.setConstructTemplate(template); query.setQueryPattern(element); return query; }
/** * True if the concept is isomorph to { ?s ?p ?o }, ?s * * @return */ public static boolean isSubjectConcept(UnaryRelation r) { Element element = r.getElement(); Var var = r.getVar(); if(element instanceof ElementTriplesBlock) { List<Triple> triples = ((ElementTriplesBlock)element).getPattern().getList(); if(triples.size() == 1) { Triple triple = triples.get(0); // TODO Refactor into e.g. ElementUtils.isVarsOnly(element) boolean condition = triple.getSubject().isVariable() && triple.getSubject().equals(var) && triple.getPredicate().isVariable() && triple.getObject().isVariable(); if(condition) { return true; } } } return false; }
rewriter = new OpRewriter(securityEvaluator, "http://example.com/dummy"); rewriter.visit(new OpBGP(BasicPattern.wrap(Arrays.asList(triples)))); Op op = rewriter.getResult(); Assert.assertTrue("Should have been an OpFilter", op = filter.getSubOp(); Assert.assertTrue("Should have been a OpBGP", op instanceof OpBGP); BasicPattern basicPattern = ((OpBGP) op).getPattern(); Assert.assertEquals(3, basicPattern.size()); Triple t = basicPattern.get(0); Assert.assertEquals(NodeFactory.createVariable("foo"), t.getSubject()); Assert.assertEquals(RDF.type.asNode(), t.getPredicate()); Assert.assertEquals(NodeFactory.createURI("http://example.com/class"), t.getObject()); t = basicPattern.get(1); Assert.assertEquals(NodeFactory.createVariable("foo"), t.getSubject()); Assert.assertTrue("Should have been blank", t.getPredicate().isBlank()); Assert.assertEquals(NodeFactory.createVariable("bar"), t.getObject()); t = basicPattern.get(2); Assert.assertEquals(NodeFactory.createVariable("bar"), t.getSubject()); Assert.assertTrue("Should have been blank", t.getPredicate().isBlank()); Assert.assertEquals(NodeFactory.createVariable("baz"), t.getObject());
public void visit(ElementTriplesBlock el) { for(Triple t : el.getPattern().getList()) { isEmpty = false; if (t.getSubject().isVariable() || t.getPredicate().isVariable() || t.getObject().isVariable()) { canBind = true; } if (defaultGraphName == null) { Quad quad = new Quad(defaultGraphName, t); quads.add(quad); } else { quads.add(new Quad(defaultGraphName, t)); } mustMatchTriple = true; } }
public static Query createQueryQuad(Quad quad) { Query query = new Query(); query.setQuerySelectType(); Node g = quad.getGraph(); Node s = quad.getSubject(); Node p = quad.getPredicate(); Node o = quad.getObject(); s = g == null || g.equals(Node.ANY) ? Vars.g : g; s = s == null || s.equals(Node.ANY) ? Vars.s : s; p = p == null || p.equals(Node.ANY) ? Vars.p : p; o = o == null || o.equals(Node.ANY) ? Vars.o : o; Triple triple = new Triple(s, p, o); BasicPattern bgp = new BasicPattern(); bgp.add(triple); Element element = new ElementTriplesBlock(bgp); element = new ElementNamedGraph(g, element); query.setQueryPattern(element); return query; }
List<Element> elements = sourceConcept.getElements(); ElementTriplesBlock etb = (ElementTriplesBlock) elements.get(0); Triple triple = etb.getPattern().get(0); Var s = (Var)triple.getSubject(); Var p = (Var)triple.getPredicate(); Var o = (Var)triple.getObject(); ExprList oExprs = new ExprList(); oExprs.add(NodeValue.makeNode(RDF.Property.asNode())); if(startVertex.equals(candidate)) { GraphPath<Node, DefaultEdge> graphPath = new GraphWalk<Node, DefaultEdge>(graph, startVertex, candidate, new ArrayList<DefaultEdge>(), 0.0); candidateGraphPaths.add(graphPath); if(current.equals(source)) { current = target; isFwd = true; else if(current.equals(target)) { current = source; isFwd = false;
public static Concept createConcept2(Node propertyNode1, Node propertyNode2) { BasicPattern pattern = new BasicPattern(); pattern.add(new Triple(vs, propertyNode1, va)); pattern.add(new Triple(va, propertyNode2, vw)); ElementTriplesBlock element = new ElementTriplesBlock(pattern); Concept result = new Concept(element, vs); return result; }
private void vars(BasicPattern bp) { for (Triple t : bp.getList()) { addVar(subjAcc, t.getSubject()); addVar(predAcc, t.getPredicate()); addVar(objAcc, t.getObject()); } }
public static Query constructBySubjects(Collection<Node> ss) { ExprVar vs = new ExprVar(s); Query query = QueryFactory.create(); query.setQueryConstructType(); query.setDistinct(true); Triple triple = new Triple(s, p, o); ElementGroup group = new ElementGroup(); group.addTriplePattern(triple); List<Expr> exprs = new ArrayList<Expr>(); for(Node item : ss) { if(!item.isURI()) { continue; } exprs.add(new E_Equals(vs, NodeValue.makeNode(item))); } if(exprs.isEmpty()) { return null; } Expr or = ExprUtils.orifyBalanced(exprs); group.addElementFilter(new ElementFilter(or)); BasicPattern bgp = new BasicPattern(); bgp.add(triple); query.setConstructTemplate(new Template(bgp)); query.setQueryPattern(group); return query; }
public static Query inOutTemplate(Node s, Node p, Node o) { Query query = QueryFactory.create(); query.setQueryConstructType(); query.setDistinct(true); Triple triple = new Triple(s, p, o); ElementGroup group = new ElementGroup(); group.addTriplePattern(triple); // Avoid non-uris as objects if(o.isVariable()) { group.addElementFilter(new ElementFilter(new E_IsURI(new ExprVar(o)))); group.addElementFilter(new ElementFilter(new E_LogicalNot(new E_IsBlank(new ExprVar(o))))); } BasicPattern bgp = new BasicPattern(); bgp.add(triple); query.setConstructTemplate(new Template(bgp)); query.setQueryPattern(group); return query; }
@Test public void bNodeSPARQL_Query_2() { String qs = "SELECT * { ?s ?p <_:BCD>}"; Query query = QueryFactory.create(qs); Op op = Algebra.compile(query); BasicPattern bp = ((OpBGP)op).getPattern(); Triple t = bp.get(0); assertEquals("BCD", t.getObject().getBlankNodeLabel()); }