@Override public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) { PropertySelector propertySelector = (PropertySelector) nodeSelector; if (propertySelector instanceof WildcardSelector) { throw new IllegalStateException(propertySelector.getClass() + " is not supported."); } Var id = Var.alloc(VarIDGenerator.createID()); elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(propertySelector.getProperty().toString()), id.asNode())); return id; } }
@Override public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) { TestingSelector testingSelector = (TestingSelector) nodeSelector; NodeTest nodeTest = testingSelector.getTest(); Var delVar = LDPathEvaluator.evaluate(testingSelector.getDelegate(), elementGroup, var, evaluatorConfiguration); IsATest isATest = (IsATest) nodeTest; elementGroup.addTriplePattern(new Triple(delVar.asNode(), RDF.type.asNode(), NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", "")))); return delVar; }
final ElementGroup eg = (ElementGroup) newQuery.getQueryPattern(); final Triple t = new Triple( Var.alloc( "s2"), Var.alloc( "p2" ), Var.alloc( "o2" )); eg.addTriplePattern( t ); newQuery.setQueryResultStar(false); newQuery.addResultVar( "s2" );
public void addTriple(Triple t) { if (query.getQueryPattern() instanceof ElementTriplesBlock) { ((ElementTriplesBlock)query.getQueryPattern()).addTriple(t); } else { assert query.getQueryPattern() instanceof ElementGroup: query.getQueryPattern(); ElementGroup group = (ElementGroup) query.getQueryPattern(); group.addTriplePattern(t); } }
@Override public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) { TestingSelector testingSelector = (TestingSelector) nodeSelector; FunctionTest functionTest = (FunctionTest) testingSelector.getTest(); if(functionTest.getArgSelectors().get(0) instanceof PropertySelector) { PropertySelector arg = (PropertySelector) functionTest.getArgSelectors().get(0); PropertySelector delegate = (PropertySelector) testingSelector.getDelegate(); Var target = Var.alloc(VarIDGenerator.createID()); elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(delegate.getProperty().toString()), target)); Var selector = Var.alloc(VarIDGenerator.createID()); elementGroup.addTriplePattern(new Triple(target.asNode(), NodeFactory.createURI(arg.getProperty().toString()), selector.asNode())); elementGroup.addElementFilter(new ElementFilter(new E_IsLiteral(new ExprVar(selector)))); return selector; } else { throw new IllegalStateException("Argument of function isLiteral has to be a PropertySelector"); } } }
@Override public Expr evaluate(NodeTest nodeTest, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) { IsATest isATest = (IsATest) nodeTest; Var tmpVar = Var.alloc(Var.alloc(VarIDGenerator.createID())); elementGroup.addTriplePattern(new Triple(var.asNode(), RDF.type.asNode(), tmpVar.asNode())); return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", "")))); } }
private void makeElementTriplePatterns(Query q, RDQL_Node node, ElementGroup group, List<String> varAcc) { int n = node.jjtGetNumChildren() ; for ( int j = 0 ; j < n ; j++ ) { Q_TriplePattern tp = (Q_TriplePattern)node.jjtGetChild(j) ; if ( tp.jjtGetNumChildren() != 3 ) throw new ARQInternalErrorException("Triple pattern has "+tp.jjtGetNumChildren()+" children") ; com.hp.hpl.jena.graph.Node nodeSubj = convertToGraphNode(tp.jjtGetChild(0), q, varAcc) ; com.hp.hpl.jena.graph.Node nodePred = convertToGraphNode(tp.jjtGetChild(1), q, varAcc) ; com.hp.hpl.jena.graph.Node nodeObj = convertToGraphNode(tp.jjtGetChild(2), q, varAcc) ; Triple t = new Triple(nodeSubj, nodePred, nodeObj) ; group.addTriplePattern(t) ; } }
public static <T extends ResourceObject> Query evaluate(QueryServiceConfiguration queryServiceDTO, URI rootType) throws ParseException { Query query = QueryFactory.make(); query.setQuerySelectType(); ElementGroup elementGroup = new ElementGroup(); Var objectVar = Var.alloc("root"); // Creating and adding the first triple - could be something like: "?objectVar rdf:type oa:Annotation Triple t1 = new Triple(objectVar, RDF.type.asNode(), NodeFactory.createURI(rootType.toString())); elementGroup.addTriplePattern(t1); // Evaluating the criteria for (Criteria c : queryServiceDTO.getCriteria()) { SesameValueBackend backend = new SesameValueBackend(); LdPathParser parser = new LdPathParser(backend, queryServiceDTO.getConfiguration(), new StringReader(c.getLdpath())); Var var = LDPathEvaluator.evaluate(parser.parseSelector(queryServiceDTO.getPrefixes()), elementGroup, objectVar, queryServiceDTO.getEvaluatorConfiguration()); if (c.getConstraint() != null) { String resolvedConstraint = resolveConstraintPrefix(c.getConstraint(), queryServiceDTO, parser); EvalComparison.evaluate(elementGroup, c, var, resolvedConstraint); } } // Adding all generated patterns to the query object query.setQueryPattern(elementGroup); // Choose what we want so select - SELECT ?annotation in this case query.addResultVar(objectVar); // Setting the default prefixes, like rdf: or dc: query.getPrefixMapping().setNsPrefixes(queryServiceDTO.getPrefixes()); return query; }