Refine search
public static Resource getPropertyResource(Resource uri){ String whereClause = "?prop " + " " + SPARQLHelper.toSPARQL(RDFS.range) + SPARQLHelper.toSPARQL(uri) + " . "; Model m = InternalModelConf.getFlatModel(); String query = SPARQLHelper.SELECT_STATEMENT.replace("[variables]", "?prop").replace("[whereClauses]", whereClause); Resource r = null; Query qry = QueryFactory.create(query); QueryExecution qe = QueryExecutionFactory.create(qry, m); ResultSet rs = qe.execSelect(); while (rs.hasNext()){ r = rs.next().get("prop").asResource(); } return r; }
@Override public Set<Predicate> getPredicates() { Set<Predicate> predicates = new TreeSet<Predicate>(); dataset.begin(ReadWrite.READ); QueryExecution qExec = null; try { qExec = QueryExecutionFactory.create(SELECT_PREDICATES_QUERY, dataset); ResultSet rs = qExec.execSelect(); while (rs.hasNext()) { predicates.add(new Predicate(rs.next().get("?p").toString(), 2)); } } finally { if (qExec != null) { qExec.close(); } dataset.end(); } return predicates; }
public static void appendConstruct(Model outModel, String queryString, Model inModel, QuerySolution bindings) { Query query=QueryFactory.create(queryString); QueryExecution qe=QueryExecutionFactory.create(query,inModel); try { if(null!=bindings) { qe.setInitialBinding(bindings); } qe.execConstruct(outModel); } finally{ qe.close(); } }
private boolean execAsk(String queryStr) { Query askQuery = QueryFactory.create(queryStr); QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, askQuery); try { return qe.execAsk(); } finally { qe.close(); } }
public static Map<RDFNode,RDFNode> fetchMap(Dataset m,Query query,QuerySolution bindings) throws Exception { QueryExecution qe=QueryExecutionFactory.create(query,m); try { ResultSet results=qe.execSelect(); Map<RDFNode,RDFNode> map=Maps.newHashMap(); List<String> vars=results.getResultVars(); while(results.hasNext()) { QuerySolution row=results.nextSolution(); map.put(row.get(vars.get(0)),row.get(vars.get(1))); } return map; } finally { qe.close(); } }
QueryExecution qexec = QueryExecutionFactory.create(query, jenaModel); ResultSet results = qexec.execSelect() ; if (!results.hasNext()) { logger.info("query does not return any answer."); return null; for ( ; results.hasNext() ; ) QuerySolution soln = results.nextSolution() ; Map<String, String> attValues = new HashMap<>(); RDFNode argNode = soln.get(arg) ; if (argNode != null) { String value = argNode.toString(); attValues.put(arg, value); return null; } finally { qexec.close() ;
private static void exec(String qs, Model model, Map<Node, List<Node>> multimap) { String preamble = StrUtils.strjoinNL("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>", "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>", "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>", "PREFIX owl: <http://www.w3.org/2002/07/owl#>", "PREFIX skos: <http://www.w3.org/2004/02/skos/core#>") ; Query query = QueryFactory.create(preamble+"\n"+qs, Syntax.syntaxARQ) ; QueryExecution qexec = QueryExecutionFactory.create(query, model) ; ResultSet rs = qexec.execSelect() ; for ( ; rs.hasNext() ; ) { QuerySolution soln= rs.next() ; Node x = soln.get("x").asNode() ; Node y = soln.get("y").asNode() ; if ( ! multimap.containsKey(x) ) multimap.put(x, new ArrayList<Node>()) ; multimap.get(x).add(y) ; } } }
/** Execute, expecting the result to be one row, one column. * Return that one RDFNode or null * Throw excpetion if more than one. */ public static RDFNode getOne(QueryExecution qExec, String varname) { try { ResultSet rs = qExec.execSelect() ; if ( ! rs.hasNext() ) return null ; QuerySolution qs = rs.nextSolution() ; RDFNode r = qs.get(varname) ; if ( rs.hasNext() ) throw new ARQException("More than one: var ?"+varname) ; return r ; } finally { qExec.close() ; } }
@Override public List<String> getAllStoredGraphs() { String queryString = "SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }"; QueryExecution qexec; if (configurationService.hasProperty(RDFUtil.STORAGE_SPARQL_LOGIN_KEY) && configurationService.hasProperty(RDFUtil.STORAGE_SPARQL_PASSWORD_KEY)) { HttpAuthenticator httpAuthenticator = new SimpleAuthenticator( configurationService.getProperty(RDFUtil.STORAGE_SPARQL_LOGIN_KEY), configurationService.getProperty(RDFUtil.STORAGE_GRAPHSTORE_PASSWORD_KEY).toCharArray()); qexec = QueryExecutionFactory.sparqlService(getSparqlEndpoint(), queryString, httpAuthenticator); } else { qexec = QueryExecutionFactory.sparqlService(getSparqlEndpoint(), queryString); } ResultSet rs = qexec.execSelect(); List<String> graphs = Collections.synchronizedList(new ArrayList<String>()); while (rs.hasNext()) { QuerySolution solution = rs.next(); if (solution.contains("g")) { graphs.add(solution.get("g").asResource().getURI()); } } qexec.close(); return graphs; }
private Map<URI, MatchResult> search(String textquery, Query sparqlQuery) { logger.debug("Executing SPARQL query: {}", sparqlQuery); QueryExecution qexec = QueryExecutionFactory.sparqlService(queryEndpoint.toString(), sparqlQuery); ResultSet resultSet = qexec.execSelect(); Map<URI, MatchResult> r = Maps.newLinkedHashMap(); while (resultSet.hasNext()) { QuerySolution solution = resultSet.next(); RDFNode s = solution.get("s"); if (s.isURIResource()) { try { String resource = s.asResource().getURI(); FreeTextMatchResult result = new FreeTextMatchResult(new URI(searchProperty + "?q=" + textquery), new URI(resource)); r.put(new URI(resource), result); } catch (URISyntaxException e) { e.printStackTrace(); } } } return r; }
private static List<Pair<String, String>> storesByQuery(String fn) { Model model = FileManager.get().loadModel(fn) ; List<Pair<String, String>> data = new ArrayList<Pair<String, String>>(); Query query = QueryFactory.create(queryString) ; QueryExecution qExec = QueryExecutionFactory.create(query, model) ; try { ResultSet rs = qExec.execSelect() ; for ( ; rs.hasNext() ; ) { QuerySolution qs = rs.nextSolution() ; String label = qs.getLiteral("label").getLexicalForm() ; String desc = qs.getResource("desc").getURI() ; data.add(new Pair<String, String>(label, desc)) ; } } finally { qExec.close() ; } return data ; } }
public ResultSet runSPARQLQuery(String queryString) { Query query = QueryFactory.create(queryString); QueryExecution qe = QueryExecutionFactory.create(query, om); return qe.execSelect(); }
ResultSet rs = qe.execSelect(); while (rs.hasNext()) QuerySolution qs = rs.next(); System.out.println(qs); System.out.println(); m = qe.execDescribe(); m.write(System.out, "N-TRIPLE"); System.out.println(qe.execAsk()); m = qe.execConstruct(); m.write(System.out, "N-TRIPLE"); qe.close(); if (m != null)
@Override public ClosableIterable<Statement> sparqlConstruct(String query) throws ModelRuntimeException, MalformedQueryException { Query jenaQuery = QueryFactory.create(query); QueryExecution qexec = QueryExecutionFactory.create(jenaQuery, this.dataset); if (jenaQuery.isConstructType()) { com.hp.hpl.jena.rdf.model.Model m = qexec.execConstruct(); Model resultModel = new ModelImplJena(null, m, Reasoning.none); resultModel.open(); return resultModel; } else { throw new RuntimeException( "Cannot handle this type of query! Please use CONSTRUCT."); } }
public SparqlRdfResultReader(String uri) { this.ds = RDFDataMgr.loadModel(uri); Query query = QueryFactory.create("ask { ?x a <http://www.w3.org/2001/sw/DataAccess/tests/result-set#ResultSet> . }"); QueryExecution qexec = QueryExecutionFactory.create(query, ds); boolean isSelectOrAsk = qexec.execAsk(); assert isSelectOrAsk; query = QueryFactory.create("ask { ?x <http://www.w3.org/2001/sw/DataAccess/tests/result-set#boolean> ?a . }"); qexec = QueryExecutionFactory.create(query, ds); boolean isAskResult = qexec.execAsk(); assert !isAskResult; query = QueryFactory.create("select distinct * where { ?x <http://www.w3.org/2001/sw/DataAccess/tests/result-set#resultVariable> ?v . }"); qexec = QueryExecutionFactory.create(query, ds); com.hp.hpl.jena.query.ResultSet results = qexec.execSelect(); this.vs = HashSetFactory.make(); for (; results.hasNext(); ) { Binding solution = results.nextBinding(); for(Iterator<Var> vs = solution.vars(); vs.hasNext(); ) { Var v = vs.next(); if ("v".equals(v.getName())) { String varName = solution.get(v).getLiteralLexicalForm(); this.vs.add(new Variable(varName)); } } } }
@Test public void special4() { Dataset ds = create() ; load1(ds.getDefaultModel()) ; load2(ds.getNamedModel("http://example/graph1")) ; load3(ds.getNamedModel("http://example/graph2")) ; Model m = ModelFactory.createDefaultModel() ; load2(m) ; load3(m) ; TDB.sync(ds) ; String qs = "PREFIX : <"+baseNS+"> SELECT (COUNT(?x) as ?c) WHERE { ?x (:p1|:p2) 'x1' }" ; Query q = QueryFactory.create(qs, Syntax.syntaxARQ) ; QueryExecution qExec = QueryExecutionFactory.create(q, ds) ; qExec.getContext().set(TDB.symUnionDefaultGraph, true) ; long c1 = qExec.execSelect().next().getLiteral("c").getLong() ; qExec.close() ; qExec = QueryExecutionFactory.create(q, m) ; long c2 = qExec.execSelect().next().getLiteral("c").getLong() ; assertEquals(c1, c2) ; qExec.close() ; }
return new ResultSetWrapper(qexec.execSelect()); } catch (QueryExecException e) { try { return Boolean.valueOf(qexec.execAsk()); } catch (QueryExecException e2) { try { return new JenaGraphAdaptor(qexec.execDescribe() .getGraph()).getImmutableGraph(); } catch (QueryExecException e3) { return new JenaGraphAdaptor(qexec.execConstruct() .getGraph()).getImmutableGraph(); qexec.close();
final List<T> parseCollection() { List<T> result=null; QuerySolutionMap parameters = new QuerySolutionMap(); parameters.add(this.targetVariable,this.resource); QueryExecution queryExecution=QueryExecutionFactory.create(this.query,this.model); queryExecution.setInitialBinding(parameters); try { ResultSet results = queryExecution.execSelect(); result=processResults(results); } finally { queryExecution.close(); } return result; }
final DocListAndSet results = new DocListAndSet(); final QueryExecution execution = QueryExecutionFactory.create( query, DatasetFactory.create( response.add(Names.QUERY_RESULT, execution.execAsk()); break; case Query.QueryTypeSelect: { if (wrapper.isHybrid()) { final ResultSetRewindable resultSet = new PagedResultSet(execution.execSelect(), rows, start); while (resultSet.hasNext()) { resultSet.next(); response.add(Names.NUM_FOUND, results.docSet.size()); } else { response.add(Names.QUERY_RESULT, execution.execSelect()); response.add(Names.QUERY_RESULT, execution.execDescribe()); break; response.add(Names.QUERY_RESULT, execution.execConstruct()); break;
public static ResultSet query(Query query, Model model) { QueryExecution qe = QueryExecutionFactory.create(query, model); ResultSet results = null; if(query.isSelectType()) { results = qe.execSelect(); } else if(query.isDescribeType()) { Iterator<Triple> triples = qe.execDescribeTriples(); results = new TripleResultSet(triples, model); } else if(query.isConstructType()) { Iterator<Triple> triples = qe.execConstructTriples(); results = new TripleResultSet(triples, model); } else if(query.isAskType()) { Boolean answer = qe.execAsk(); List<Boolean> result = new ArrayList<Boolean>(); result.add(answer); results = new BooleanResultSet(result.iterator(), model); } return results; }