/* @see org.mindswap.common.Parser#parse(java.lang.Object) */
public ABoxQuery<Variable> parse(final String queryString) throws ParseException {
if (queryString == null) throw new ParseException(queryString, "Query string null.");
final Query query;
try {
switch (lang) {
case RDQL:
query = QueryFactory.create(queryString, Syntax.syntaxRDQL);
break;
case SPARQL_DL:
case SPARQL:
default:
query = QueryFactory.create(queryString, Syntax.syntaxSPARQL);
break;
}
} catch (final QueryException e) {
throw new ParseException(queryString, e);
}
final ISWRLFactory swrlFactory = SWRLFactory.createFactory(model);
final Map<String, Variable> vars = new HashMap<String, Variable>();
final Element elmnt = query.getQueryPattern();
final ElementVisitor v = new ElementVisitor(model, swrlFactory, vars);
elmnt.visit(v);
final OWLList<Atom> atomList = v.getAtomList();
final List<Variable> resultVars = new ArrayList<Variable>();
for (final String var : query.getResultVars()) {
resultVars.add(vars.get("?" + var));
}
return new ABoxQuery<Variable>(atomList, resultVars);
}
@Test
public void testDetectSelectStar() {
Query selectStar = QueryFactory.create("SELECT * { ?s ?p ?o }");
assertTrue(selectStar.isQueryResultStar());
Query selectVars = QueryFactory.create("SELECT ?s ?p ?o { ?s ?p ?o }");
assertFalse(selectVars.isQueryResultStar());
}
/**
* Returns a collection of RDFStatements that match the described subject
*
* @param subject Subject
* @return collection of RDFStatements
*/
public Collection<RDFStatement> getStatements(String subject) {
if (subject == null || subject.isEmpty()) {
return null;
}
List<RDFStatement> statement = null;
try {
// define a describe query
String query = String.format("DESCRIBE %s FROM < %s >", subject, this.graphName);
logger.debug("Query: \n{}", query);
Query sparqlQuery = QueryFactory.create(query);
VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(sparqlQuery, this.graph);
// execute the query and get the graph
Model model = vqe.execDescribe();
Graph queriedGraph = model.getGraph();
// itreate over the retrieved triples, and place them inside a list
ExtendedIterator<Triple> iter = queriedGraph.find(Node.ANY, Node.ANY, Node.ANY);
statement = new ArrayList<>();
while (iter.hasNext()) {
Triple t = (Triple) iter.next();
RDFStatement stmt =
new RDFStatement(
t.getSubject().toString(), t.getPredicate().toString(), t.getObject().toString());
statement.add(stmt);
}
} catch (Exception ex) {
logger.error("Exception occured while querying for statements", ex);
}
return statement;
}
private static Set<Property> getPermissions(String userPrefix, String username, String uri) {
Set<Property> permissions = new HashSet<Property>();
Resource resource = configModel.createResource(uri);
Resource user;
if (username == null) user = PERM.Public;
else user = configModel.createResource(userPrefix + username);
StmtIterator stmts = configModel.listStatements(user, null, resource);
while (stmts.hasNext()) permissions.add(stmts.next().getPredicate());
String queryString = "";
queryString += "PREFIX perm: <http://vocab.ox.ac.uk/perm#>\n";
queryString += "SELECT ?perm ?regex WHERE {\n";
queryString += " <" + user.getURI() + "> ?perm ?rm .";
queryString += " ?rm a perm:ResourceMatch ;";
queryString += " perm:matchExpression ?regex }";
com.hp.hpl.jena.query.Query query = QueryFactory.create(queryString);
QueryExecution qexec = QueryExecutionFactory.create(query, configModel);
ResultSet results = qexec.execSelect();
while (results.hasNext()) {
QuerySolution sol = results.next();
if (uri.matches(((Literal) sol.get("regex")).getLexicalForm()))
permissions.add(configModel.createProperty(((Resource) sol.get("perm")).getURI()));
}
if (username != null) permissions.addAll(getPermissions(userPrefix, null, uri));
return permissions;
}
private ResultSet executeQuery(String queryText, Model dataset) {
QueryExecution queryExecution = null;
Query query = QueryFactory.create(queryText, SYNTAX);
queryExecution = QueryExecutionFactory.create(query, dataset);
return queryExecution.execSelect();
}
// NEED -> SUPERCLASSE
private ArrayList<java.net.URI> getSuperClassFromUri(String uri) {
String queryBegin =
"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
+ "PREFIX mstr: <http://methodo-stat-tutor.com#>\n"
+ "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
+ "PREFIX owl: <http://www.w3.org/2002/07/owl#> \n"
+ "PREFIX sparqldl: <http://pellet.owldl.com/ns/sdle#>\n "
+ "SELECT DISTINCT ?SUPERCLASS ?LAB ?COM \n"
+ "WHERE {";
String queryEnd = "}";
String queryStr2 =
queryBegin
+
// "?titi owl:Class ?CLASS ." +
// "?NOTION a ?CLASS ." +
"?CLASS sparqldl:directSubClassOf ?SUPERCLASS ."
+ "OPTIONAL {?SUPERCLASS rdfs:label ?LAB} ."
+ "OPTIONAL {?SUPERCLASS rdfs:comment ?COM} ."
+ "FILTER (?CLASS = <"
+ uri
+ ">)"
+ queryEnd;
log.error(queryStr2);
Query query2 = QueryFactory.create(queryStr2);
ResultSet results = SparqlDLExecutionFactory.create(query2, ontModel).execSelect();
ArrayList<java.net.URI> aru = new ArrayList<java.net.URI>();
while (results.hasNext()) {
aru.add(java.net.URI.create(results.next().get("?SUPERCLASS").toString()));
}
return aru;
}
public static int getDataMatrix(Model model) {
String sparqlQuery =
String.format(
"PREFIX ot:<%s>\n"
+ "PREFIX isa:<%s>\n"
+ "PREFIX dcterms:<http://purl.org/dc/terms/>\n"
+ "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
+ "PREFIX rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
+ "SELECT ?node ?feature ?title ?value where {\n"
+ " ?node rdf:type isa:Data."
+ " ?feature ot:hasSource ?node."
+ " ?feature dcterms:title ?title."
+ " ?fv ot:feature ?feature."
+ " ?fv ot:value ?value."
+ "} ORDER by ?node ?sample \n",
OT.NS, ISA.URI);
// Hashtable<String,Hashtable<String,String>> lookup = new Hashtable<String,
// Hashtable<String,String>>();
Query query = QueryFactory.create(sparqlQuery);
QueryExecution qe = QueryExecutionFactory.create(query, model);
ResultSet rs = qe.execSelect();
int row = 0;
while (rs.hasNext()) {
QuerySolution qs = rs.next();
RDFNode node = qs.get("node");
RDFNode feature = qs.get("feature");
RDFNode title = qs.get("title");
RDFNode value = qs.get("value");
row++;
}
return row; // lookup;
}
public String sparql(String qry) {
Model model = ModelFactory.createDefaultModel();
try {
model.read(new FileInputStream("D:/AI Project/harsh/myNew.owl"), null, "RDF");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
String res = null;
String res1 = null;
Query query = QueryFactory.create(qry);
QueryExecution exec = QueryExecutionFactory.create(query, model);
try {
ResultSet rs = exec.execSelect();
while (rs.hasNext()) {
QuerySolution soln = rs.nextSolution();
// res = soln.get("dn").toString();
res = soln.get("dn").toString();
System.out.println(res);
System.out.println("HAS");
res1 = soln.get("rn").toString();
System.out.println(res1);
}
} finally {
exec.close();
}
return res;
}
/**
* This method constructs numeric {@link OpFilter} instance with given index value and using given
* substituted {@link OpFilter} instance
*
* @param index to add all variables in filter block
* @param substitutedOp {@link OpFilter} instance whose filter block will be turned into numeric
* one.
* @return numeric {@link OpFilter} instance
*/
private static Op constructNumericOpFilter(int index, Op substitutedOp) {
Op numericOpFilter = substitutedOp;
// check whether op instance is an OpFilter
if (substitutedOp instanceof OpFilter) {
// turn OpFilter into query
Query query = OpAsQuery.asQuery(substitutedOp);
// System.out.println("Query before: " + query);
// assign index
final int finalIndex = index;
// construct numeric filter block
List<VariablePair> variablePairs = constructVariablePairs(query, finalIndex);
// get query as text
String queryStr = query.toString();
// split query and get filter including second part of query text
String[] splittedQuery = queryStr.split(FILTER_KEYWORD);
// replace variables of given text
String filterIncludingPart = replaceVariables(variablePairs, splittedQuery[1]);
// construct final query
String finalQueryText = splittedQuery[0] + FILTER_KEYWORD + filterIncludingPart;
// System.out.println("Query after: " + finalQueryText);
// create plan for query and get OpFilter instance from it
numericOpFilter =
QueryExecutionFactory.createPlan(
QueryFactory.create(finalQueryText), DatasetGraphFactory.createMem(), null)
.getOp();
}
return numericOpFilter;
}
/**
* Queries the {@link #rdfEndpoint(String)} with each of the {@link #rdfQueries} and harvests the
* results of the query.
*/
private void harvestFromEndpoint() {
Query query;
QueryExecution qExec;
for (String rdfQuery : rdfQueries) {
if (closed) break;
logger.info(
"Harvesting with query: [{}] on index [{}] and type [{}]", rdfQuery, indexName, typeName);
try {
query = QueryFactory.create(rdfQuery);
} catch (QueryParseException qpe) {
logger.error("Could not parse [{}]. Please provide a relevant query. {}", rdfQuery, qpe);
continue;
}
qExec = QueryExecutionFactory.sparqlService(rdfEndpoint, query);
try {
harvest(qExec);
} catch (Exception e) {
logger.error("Exception [{}] occurred while harvesting", e.getLocalizedMessage());
} finally {
qExec.close();
}
}
}
public static QuerySolution evaluationOfSPARQLQueryAgainstModel(String queryString, Model model) {
// that will be our result
QuerySolution soln = null;
// Create a SPARQL query from the given string
Query query = QueryFactory.create(queryString);
// Create a QueryExecution to execute over the Model.
QueryExecution qexec = QueryExecutionFactory.create(query, model);
try {
// Results from a query in a table-like manner for SELECT queries. Each row corresponds to a
// set of bindings which fulfill the conditions of the query. Access to the results is by
// variable name.
ResultSet results = qexec.execSelect();
while (results.hasNext()) {
// QuerySolution -- A single answer from a SELECT query.
// results.nextSolution() -- Moves to the next result
soln = results.nextSolution();
}
} finally {
qexec.close();
}
return soln;
}
public static void main(String[] args) {
// String sA = "Select * { ?s ?p ?o . Filter((?s || ?p) && ?o) . }";
// String sA = "Select * { ?s ?p ?o . Filter((?s || ?p) && !(?o || ?g)) . }";
String sA =
"Select * { ?s ?p ?o . Filter(?o != <http://Person>). Optional { { ?x ?y ?z . Filter(?x != <http://x> && ?x = ?y) . } Union { ?x a ?y . Filter(?x = <http://x>) . } } . }";
// String sA = "Select * { ?s ?p ?o . Filter(!(?s = ?p || ?p = ?o && ?s = ?o || ?o = ?s)) . }";
// String sA = "Select * { ?s ?p ?o . Filter(!(?s = ?p || ?j = <http://x>)) . }";
Query qA = QueryFactory.create(sA);
Op opA = Algebra.compile(qA);
opA = Algebra.toQuadForm(opA);
System.out.println(opA);
// How to deal with union? variables appearing in them
// System.out.println(opA.getClass());
ExprList exprs = FilterUtils.collectExprs(opA, new ExprList());
ExprList proc = eval(exprs);
System.out.println(proc);
List<ExprList> clauses = dnfToClauses(proc);
System.out.println("Mentioned vars:" + proc.getVarsMentioned());
System.out.println("Clauses: " + clauses);
}
@Test
public void testQueryAddValuesInQueryPattern() {
List<Var> header = vars("a", "b");
Binding b1 = binding(header, "1", "2");
Binding b2 = binding(header, "3", "4");
Query q = QueryFactory.create("SELECT * {}");
ElementGroup group = new ElementGroup();
ElementData table = new ElementData();
table.add(Var.alloc("a"));
table.add(Var.alloc("b"));
table.add(b1);
table.add(b2);
group.addElement(q.getQueryPattern());
group.addElement(table);
q.setQueryPattern(group);
ResultSet rs = QueryExecutionFactory.create(q, ModelFactory.createDefaultModel()).execSelect();
assertEquals(Arrays.asList(new String[] {"a", "b"}), rs.getResultVars());
assertTrue(rs.hasNext());
assertEquals(b1, rs.nextBinding());
assertTrue(rs.hasNext());
assertEquals(b2, rs.nextBinding());
assertFalse(rs.hasNext());
}
@SuppressWarnings("unchecked")
private static List<RDFNode> getURIObjects() {
List<RDFNode> objectsURIs = new ArrayList<RDFNode>();
if (demo) { // Deserialize the results if exists (For Demo purpose)
if (useCache) {
try {
List<String> ser = new ArrayList<String>();
File file = new File("URIObjects.ser");
if (file.exists()) {
ObjectInputStream in;
in = new ObjectInputStream(new FileInputStream(file));
ser = (List<String>) in.readObject();
in.close();
// convert every object back from string
for (String n : ser) {
objectsURIs.add(ResourceFactory.createResource(n));
}
return objectsURIs;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
// create a query to retrieve URIs objects
String queryString =
"SELECT * "
+ "WHERE { ?s ?p ?o . FILTER (isURI(?o)) . "
+ "FILTER (STRSTARTS(STR(?o), \""
+ resourcePrefix
+ "\"))}";
Query query = QueryFactory.create(queryString);
QueryExecution exec = QueryExecutionFactory.create(query, localModel);
ResultSet rs = exec.execSelect();
while (rs.hasNext()) {
QuerySolution sol = rs.next();
RDFNode object = sol.get("?o");
objectsURIs.add(object);
}
if (demo) { // serialize the output (for Demo purpose)
try {
FileOutputStream fileOut = new FileOutputStream("URIObjects.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
// convert to Serializabe Strings
List<String> l = new ArrayList<String>();
for (RDFNode n : objectsURIs) {
l.add(n.toString());
}
out.writeObject(l);
out.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
return objectsURIs;
}
@Test
public void testSPARQLFilterIsAppliedToValues() {
Query q = QueryFactory.create("SELECT * { FILTER(?a=1) VALUES (?a) { (1) (2) } }");
ResultSet rs = QueryExecutionFactory.create(q, ModelFactory.createDefaultModel()).execSelect();
assertTrue(rs.hasNext());
assertEquals(binding(vars("a"), "1"), rs.nextBinding());
assertFalse(rs.hasNext());
}
private Set<String> extractVars(String query) {
log.debug(" {}", query);
Query q = QueryFactory.create(query);
Element element = q.getQueryPattern();
ElementWalker.walk(element, collector);
Set<String> vars = collector.getVariables();
log.debug(" > {}", vars);
return vars;
}
static {
try {
dataPropertyValueQuery = QueryFactory.create(DATA_PROPERTY_VALUE_QUERY_STRING);
} catch (Throwable th) {
log.error(
"could not create SPARQL query for DATA_PROPERTY_VALUE_QUERY_STRING " + th.getMessage());
log.error(DATA_PROPERTY_VALUE_QUERY_STRING);
}
}
@Override
public void processResults() {
String queryBegin =
"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>"
+ "PREFIX mstr: <http://methodo-stat-tutor.com#>"
+ "SELECT ?NOTION "
+ "WHERE {";
String queryEnd = "}";
// create a query that asks for the color of the wine that
// would go with each meal course
String queryStr2 =
queryBegin
+ " ?EXO mstr:traiteNotion ?NOTION ."
+ "FILTER (?EXO = mstr:"
+ this.exercise
+ ")\n"
+ queryEnd;
log.error(queryStr2);
Query query2 = QueryFactory.create(queryStr2);
ResultSet results = SparqlDLExecutionFactory.create(query2, ontModel).execSelect();
ArrayList<java.net.URI> needNotion = new ArrayList<java.net.URI>();
ArrayList<java.net.URI> giveNotion = new ArrayList<java.net.URI>();
while (results.hasNext()) {
RDFNode a = results.next().get("?NOTION");
giveNotion.add(java.net.URI.create(a.asLiteral().getString()));
needNotion.addAll(getSuperClassFromUri(a.asLiteral().getString()));
}
// remove duplicates from neednotion
Set<java.net.URI> hs = new HashSet<>();
hs.addAll(needNotion);
needNotion.clear();
needNotion.addAll(hs);
// end remove duplicate
this.needNotion = needNotion;
this.giveNotion = giveNotion;
// ajout des notions au modele
int i = 0;
while (i < needNotion.size()) {
log.error(needNotion.get(i).toString());
addStatementToOntModel("needNotion", needNotion.get(i).toString());
i++;
}
i = 0;
while (i < giveNotion.size()) {
log.error(giveNotion.get(i).toString());
addStatementToOntModel("giveNotion", giveNotion.get(i).toString());
i++;
}
}
public String getQcmNotion() {
String queryBegin =
"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
+ "PREFIX mstr: <http://methodo-stat-tutor.com#>\n"
+ "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n"
+ "PREFIX owl: <http://www.w3.org/2002/07/owl#> \n"
+ "PREFIX sparqldl: <http://pellet.owldl.com/ns/sdle#>\n "
+ "SELECT ?NOTION ?NOTIONLAB ?NOTIONCOMM ?TYP \n"
+ "WHERE {";
String queryEnd = "}";
// create a query that asks for the color of the wine that
// would go with each meal course
String queryStr2 =
queryBegin
+ "{?EXO a mstr:Qcm .\n"
+ " ?EXO mstr:traiteNotion ?NOTION .\n"
+ " BIND(IRI(str(?NOTION)) as ?NOTION_IRI) .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:label ?NOTIONLAB } .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:comment ?NOTIONCOMM } \n"
+ "values ?TYP { 'traite' }\n"
+ "FILTER (?EXO = mstr:"
+ this.exercise
+ ")\n"
+ "}\n"
+ "UNION \n"
+ "{?EXO a mstr:Qcm .\n"
+ " ?EXO mstr:needNotion ?NOTION .\n"
+ " BIND(IRI(str(?NOTION)) as ?NOTION_IRI) .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:label ?NOTIONLAB } .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:comment ?NOTIONCOMM } \n"
+ "values ?TYP { 'need' }\n"
+ "FILTER (?EXO = mstr:"
+ this.exercise
+ ")"
+ "}"
+ "UNION \n"
+ "{?EXO a mstr:Qcm .\n"
+ " ?EXO mstr:giveNotion ?NOTION .\n"
+ " BIND(IRI(str(?NOTION)) as ?NOTION_IRI) .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:label ?NOTIONLAB } .\n"
+ "OPTIONAL { ?NOTION_IRI rdfs:comment ?NOTIONCOMM } \n"
+ "values ?TYP { 'give' }\n"
+ "FILTER (?EXO = mstr:"
+ this.exercise
+ ")"
+ " }"
+ queryEnd;
log.error(queryStr2);
Query query2 = QueryFactory.create(queryStr2);
ResultSet results = SparqlDLExecutionFactory.create(query2, ontModel).execSelect();
String str = MstrUtils.getSparqlResultsetAsJson(results);
return str;
}
@Override
public QueryExecution apply(final Dataset dataset) {
try {
final Model model = unifyDatasetModel(dataset);
final Query sparqlQuery = QueryFactory.create(IOUtils.toString(query));
return QueryExecutionFactory.create(sparqlQuery, model);
} catch (final IOException e) {
throw new IllegalStateException(e);
}
}
/**
* Execute an ASK query
*
* @param query
* @return
*/
public boolean executeAskQuery(String query) {
Query query1 = QueryFactory.create(query);
QueryExecution qexec = QueryExecutionFactory.create(query1, ontologie);
try {
if (query.toLowerCase().contains("ask")) {
return (qexec.execAsk());
}
} finally {
qexec.close();
}
return false;
}
// method to get Hospital list given treatment type
public static void issueSPARQLTreatment_Hospital(
Model m, String treatMent_Name, HashMap hos_treatment) {
/**
* **************************************Getting test name type by cancer
* name********************************************************
*/
String causes_val = treatMent_Name;
// String drug="HPV";
String defaultNameSpace =
"http://www.semanticweb.org/janani/ontologies/2015/3/cancer-treatment#";
String offersNameSpace =
"<http://www.semanticweb.org/janani/ontologies/2015/3/cancer-treatment#offers>";
String ntemp1 = "<" + defaultNameSpace + treatMent_Name + ">";
String temp1 = "";
temp1 = temp1 + " ?Hospital " + offersNameSpace + " " + ntemp1 + " .";
String queryStringDrug = "SELECT ?Hospital " + "WHERE {" + temp1 + " }";
System.out.println(queryStringDrug);
Query query1 = QueryFactory.create(queryStringDrug);
QueryExecution qe1 = QueryExecutionFactory.create(query1, m);
ResultSet results1 = qe1.execSelect();
// ResultSetFormatter.out(System.out, results1, query1);
RDFNode hospital_name;
// System.out.println("Treatment is: "+ treatMent_Name);
// System.out.println("Hospitals are: ");
while (results1.hasNext()) {
String[] Hos_name;
QuerySolution querySolution = results1.next();
hospital_name = querySolution.get("Hospital");
String temp_val = String.valueOf(hospital_name);
Hos_name = temp_val.split("#");
// System.out.println(Hos_name[1]);
hos_treatment.put(treatMent_Name, Hos_name[1]);
// if(!Hospital_list.contains(Hos_name[1]))
// {
// Hospital_list.add(Hos_name[1]);
// // System.out.println(Hos_name[1]);
// }
}
}
/** Rigourous Test :-) */
public void testApp() {
final List resultvars = QueryFactory.create("select ?x ?y WHERE {?x a ?Y}").getResultVars();
System.out.println(
ResultSetFormatter.asXMLString(
new ResultSet() {
public Model getResourceModel() {
// TODO Auto-generated method stub
return null;
}
public List getResultVars() {
// TODO Auto-generated method stub
return resultvars;
}
public int getRowNumber() {
// TODO Auto-generated method stub
return 0;
}
public boolean hasNext() {
// TODO Auto-generated method stub
return false;
}
public boolean isOrdered() {
// TODO Auto-generated method stub
return false;
}
public Object next() {
// TODO Auto-generated method stub
return null;
}
public Binding nextBinding() {
// TODO Auto-generated method stub
return null;
}
public QuerySolution nextSolution() {
// TODO Auto-generated method stub
return null;
}
public void remove() {
// TODO Auto-generated method stub
}
}));
}
private void compareQuery(URL htmlURL, URL compareURL) throws SAXException, IOException {
Query query = QueryFactory.read(compareURL.toExternalForm());
Map<String, Query> qs =
QueryUtilities.makeQueries(ParserFactory.Format.XHTML, htmlURL.toExternalForm());
assertTrue("We have a query", qs.size() != 0);
Query qFromHTML = qs.get(qs.keySet().toArray()[0]);
assertEquals(
"Query matches (" + htmlURL + ")", Algebra.compile(query), Algebra.compile(qFromHTML));
}
public String executeQuery(String queryString) {
/*
//System.out.println(queryString);
Query query = QueryFactory.create(queryString);
QueryExecution qe = QueryExecutionFactory.create(query, model);
ResultSet results = qe.execSelect();
ByteArrayOutputStream ostream = new ByteArrayOutputStream();
ResultSetFormatter.out(ostream, results, query);
//ResultSetFormatter.out(System.out, results, query);
String r = "";
try{
r = new String(ostream.toByteArray(), "UTF-8");
//System.out.println(r);
}
catch(Exception e){
System.out.println(e.getMessage());
}
qe.close();
return r;
*/
//// new added for test JSON output
try {
Query query = QueryFactory.create(queryString);
QueryExecution qe = QueryExecutionFactory.create(query, model);
ResultSet results = qe.execSelect();
ByteArrayOutputStream ostream = new ByteArrayOutputStream();
ResultSetFormatter.outputAsJSON(ostream, results);
// ResultSetFormatter.out(ostream, results, query);
// ResultSetFormatter.out(System.out, results, query);
String r = "";
try {
r = new String(ostream.toByteArray(), "UTF-8");
// System.out.println(r);
} catch (Exception e) {
System.out.println(e.getMessage());
}
qe.close();
return r;
} catch (Exception e) {
System.out.println(e.toString());
return "";
}
}
/**
* The constructor of the SPARQL list object.
*
* @param store The reference to the data store.
* @param query The string containing the query.
* @throws PersistanceQueryException
*/
public JenaSPARQLList(Model store, String queryString) throws PersistanceQueryException {
try {
Query query = QueryFactory.create(queryString);
QueryExecution executioner = QueryExecutionFactory.create(query, store);
ResultSet resultSet = executioner.execSelect();
while (resultSet.hasNext()) {
QuerySolution solution = resultSet.nextSolution();
JenaPersistanceResultRow row = new JenaPersistanceResultRow(store, solution);
this.add(row);
}
} catch (Exception ex) {
log.error("Failed to execute the query : " + ex.getMessage(), ex);
throw new PersistanceQueryException("Failed to execute the query : " + ex.getMessage(), ex);
}
}
@Override
public QueryResult query(String queryString, String language, String baseURI) {
Model graph = null;
GraphConnection graphConnection = null;
QueryResult res = null;
QueryExecution qe = null;
try {
graphConnection = openGraph();
graph = graphConnection.getGraph();
graph.enterCriticalSection(Lock.READ);
log.debug(String.format("Running query %s", queryString));
// XXX AT: ignore language for now
if (language != null && !language.equals("sparql")) {
log.warn(String.format("Unknown language %s for query, using SPARQL", language));
}
Query query = QueryFactory.create(queryString);
query.setBaseURI(baseURI);
qe = QueryExecutionFactory.create(query, graph);
res = new QueryResultImpl(0, new ArrayList<String>(), new ArrayList<Map<String, Node>>());
ResultSet jenaResults = qe.execSelect();
Integer count = 0;
List<String> variableNames = jenaResults.getResultVars();
List<Map<String, Node>> nuxResults = new ArrayList<Map<String, Node>>();
while (jenaResults.hasNext()) {
QuerySolution soln = jenaResults.nextSolution();
Map<String, Node> nuxSol = new HashMap<String, Node>();
for (String varName : variableNames) {
RDFNode x = soln.get(varName);
nuxSol.put(varName, getNXRelationsNode(x.asNode()));
}
nuxResults.add(nuxSol);
count++;
}
res = new QueryResultImpl(count, variableNames, nuxResults);
} finally {
if (qe != null) {
// Important - free up resources used running the query
qe.close();
}
if (graph != null) {
graph.leaveCriticalSection();
}
if (graphConnection != null) {
graphConnection.close();
}
}
return res;
}
private void cachingForTriples(Table table, String endpoint) {
Model model = ModelFactory.createDefaultModel();
List<String> resources = null;
FileWriter fstream = null;
try {
fstream = new FileWriter("/home/mofeed/TrialStart/zicozico.nt");
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
BufferedWriter out = new BufferedWriter(fstream);
try {
for (Object id : table.getItemIds()) {
Item item = table.getItem(id);
Property sourceURI = item.getItemProperty("sourceURI"); // vaadin property not jena
Resource resource = model.createResource();
try {
String sparqlQuery = "select distinct * where { <" + sourceURI.getValue() + "> ?p ?o .}";
Query query = QueryFactory.create(sparqlQuery);
QueryExecution qexec = QueryExecutionFactory.sparqlService(endpoint, query);
com.hp.hpl.jena.query.ResultSet results = qexec.execSelect();
com.hp.hpl.jena.query.QuerySolution binding = null;
while (results.hasNext()) {
binding = results.next();
String property = binding.getResource("?p").toString();
String value;
if (binding.get("?o").isResource()) value = binding.getResource("?o").toString();
else value = binding.getLiteral("?o").toString();
com.hp.hpl.jena.rdf.model.Property pt = ResourceFactory.createProperty(property);
// resource.addProperty(pt, value);
model.add(resource, pt, value);
}
qexec.close();
model.write(out, null, "TURTLE");
} catch (Exception e) {
Notification.show(e.toString());
}
// model.add(s, p, o);
// Property destinationURI = item.getItemProperty("destinationURI");
// out.write(sourceURI.getValue()+"\n");
}
/*out.flush();
fstream.flush();*/
out.close();
} catch (Exception e) { // Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
/**
* Selects a triple by providing an RDFStatement object collection
*
* @param stmts
* @return Query result
*/
public List<RDFStatement> selectTriples(Collection<? extends RDFStatement> stmts) {
if (stmts == null || stmts.isEmpty()) {
return null;
}
RDFStatement rdfs = stmts.stream().findFirst().get();
String si = rdfs.getSubject(),
pi = rdfs.getPredicate(),
oi = rdfs.getObject(); // doesnt get value
StringBuilder sb = new StringBuilder();
stmts
.stream()
.forEach(
s -> {
s.setObject(RDFUtils.escapeString(s.getObject()));
sb.append(s.getSubject())
.append(" ")
.append(s.getPredicate())
.append(" ")
.append(s.getObject())
.append(" .\n");
});
String query =
String.format(
this.defaultPrefices + "SELECT * FROM <%s> WHERE { %s }",
this.graphName,
sb.toString());
Query sparqlQuery = QueryFactory.create(query);
VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(sparqlQuery, this.graph);
List<RDFStatement> stmtsList = new ArrayList<>();
ResultSet rs = vqe.execSelect();
while (rs.hasNext()) {
QuerySolution qs = rs.nextSolution();
RDFNode s = qs.get(si);
RDFNode p = qs.get(pi);
RDFNode o = qs.get(oi);
RDFStatement stmt =
new RDFStatement(
s != null ? s.toString() : "null",
p != null ? p.toString() : "null",
o != null ? RDFUtils.escapeString(o.toString()) : "null");
stmtsList.add(stmt);
logger.info("fetched: {}", stmt.toString());
}
return stmtsList;
}
private static void query(Dataset dataset) {
Query q =
QueryFactory.create(
"PREFIX pf: <http://jena.hpl.hp.com/ARQ/property#>"
+ "SELECT * WHERE {"
+ " GRAPH ?g { "
+ " ?doc ?p ?lit ."
+ " (?lit ?score ) pf:textMatch '+london' ."
+ " } "
+ "}");
QueryExecution qe = QueryExecutionFactory.create(q, dataset);
ResultSet res = qe.execSelect();
ResultSetFormatter.out(res);
qe.close();
}
