/**
* Query SPARQL endpoint with a SELECT query
*
* @param qExec QueryExecution encapsulating the query
* @return model retrieved by querying the endpoint
*/
private Model getSelectModel(QueryExecution qExec) {
Model model = ModelFactory.createDefaultModel();
Graph graph = model.getGraph();
ResultSet results = qExec.execSelect();
while (results.hasNext()) {
QuerySolution sol = results.next();
String subject;
String predicate;
RDFNode object;
try {
subject = sol.getResource("s").toString();
predicate = sol.getResource("p").toString();
object = sol.get("o");
} catch (NoSuchElementException e) {
logger.error("SELECT query does not return a (?s ?p ?o) Triple");
continue;
}
Node objNode;
if (object.isLiteral()) {
Literal obj = object.asLiteral();
objNode = NodeFactory.createLiteral(obj.getString(), obj.getDatatype());
} else {
objNode = NodeFactory.createLiteral(object.toString());
}
graph.add(
new Triple(NodeFactory.createURI(subject), NodeFactory.createURI(predicate), objNode));
}
return model;
}
void runTestSelect(Query query, QueryExecution qe) throws Exception {
// Do the query!
ResultSetRewindable resultsActual = ResultSetFactory.makeRewindable(qe.execSelect());
qe.close();
if (results == null) return;
// Assumes resultSetCompare can cope with full isomorphism possibilities.
ResultSetRewindable resultsExpected;
if (results.isResultSet())
resultsExpected = ResultSetFactory.makeRewindable(results.getResultSet());
else if (results.isModel())
resultsExpected = ResultSetFactory.makeRewindable(results.getModel());
else {
fail("Wrong result type for SELECT query");
resultsExpected = null; // Keep the compiler happy
}
if (query.isReduced()) {
// Reduced - best we can do is DISTINCT
resultsExpected = unique(resultsExpected);
resultsActual = unique(resultsActual);
}
// Hack for CSV : tests involving bNodes need manually checking.
if (testItem.getResultFile().endsWith(".csv")) {
resultsActual = convertToStrings(resultsActual);
resultsActual.reset();
int nActual = ResultSetFormatter.consume(resultsActual);
int nExpected = ResultSetFormatter.consume(resultsExpected);
resultsActual.reset();
resultsExpected.reset();
assertEquals("CSV: Different number of rows", nExpected, nActual);
boolean b = resultSetEquivalent(query, resultsExpected, resultsActual);
if (!b) System.out.println("Manual check of CSV results required: " + testItem.getName());
return;
}
boolean b = resultSetEquivalent(query, resultsExpected, resultsActual);
if (!b) {
resultsExpected.reset();
resultsActual.reset();
boolean b2 = resultSetEquivalent(query, resultsExpected, resultsActual);
printFailedResultSetTest(query, qe, resultsExpected, resultsActual);
}
assertTrue("Results do not match: " + testItem.getName(), b);
return;
}
/**
* Perform the {@link QueryExecution} once.
*
* @param action
* @param queryExecution
* @param query
* @param queryStringLog Informational string created from the initial query.
* @return
*/
protected SPARQLResult executeQuery(
HttpAction action, QueryExecution queryExecution, Query query, String queryStringLog) {
setAnyTimeouts(queryExecution, action);
if (query.isSelectType()) {
ResultSet rs = queryExecution.execSelect();
// Force some query execution now.
// If the timeout-first-row goes off, the output stream has not
// been started so the HTTP error code is sent.
rs.hasNext();
// If we wanted perfect query time cancellation, we could consume
// the result now to see if the timeout-end-of-query goes off.
// rs = ResultSetFactory.copyResults(rs) ;
// action.log.info(format("[%d] exec/select", action.id)) ;
return new SPARQLResult(rs);
}
if (query.isConstructType()) {
Dataset dataset = queryExecution.execConstructDataset();
// action.log.info(format("[%d] exec/construct", action.id));
return new SPARQLResult(dataset);
}
if (query.isDescribeType()) {
Model model = queryExecution.execDescribe();
// action.log.info(format("[%d] exec/describe", action.id)) ;
return new SPARQLResult(model);
}
if (query.isAskType()) {
boolean b = queryExecution.execAsk();
// action.log.info(format("[%d] exec/ask", action.id)) ;
return new SPARQLResult(b);
}
ServletOps.errorBadRequest("Unknown query type - " + queryStringLog);
return null;
}
/**
* Returns the string value of the first of the properties in the uriDescriptionList for the given
* resource (as an URI). In case the resource does not have any of the properties mentioned, its
* URI is returned. The value is obtained by querying the endpoint and the endpoint is queried
* repeatedly until it gives a response (value or the lack of it)
*
* <p>It is highly recommended that the list contains properties like labels or titles, with test
* values.
*
* @param uri - the URI for which a label is required
* @return a String value, either a label for the parameter or its value if no label is obtained
* from the endpoint
*/
private String getLabelForUri(String uri) {
String result;
if (uriLabelCache.containsKey(uri)) {
return uriLabelCache.get(uri);
}
for (String prop : uriDescriptionList) {
String innerQuery = "SELECT ?r WHERE {<" + uri + "> <" + prop + "> ?r } LIMIT 1";
try {
Query query = QueryFactory.create(innerQuery);
QueryExecution qExec = QueryExecutionFactory.sparqlService(rdfEndpoint, query);
boolean keepTrying = true;
while (keepTrying) {
keepTrying = false;
try {
ResultSet results = qExec.execSelect();
if (results.hasNext()) {
QuerySolution sol = results.nextSolution();
result = EEASettings.parseForJson(sol.getLiteral("r").getLexicalForm());
if (!result.isEmpty()) {
uriLabelCache.put(uri, result);
return result;
}
}
} catch (Exception e) {
keepTrying = true;
logger.warn("Could not get label for uri {}. Retrying.", uri);
} finally {
qExec.close();
}
}
} catch (QueryParseException qpe) {
logger.error("Exception for query {}. The label cannot be obtained", innerQuery);
}
}
return uri;
}
/**
* Get a set of unique queryObjName returned from a select query
*
* <p>Used to retrieve sets of modified objects used in sync
*
* @param rdfQuery query to execute
* @param queryObjName name of the object returned
* @return set of values for queryObjectName in the rdfQuery result
*/
HashSet<String> executeSyncQuery(String rdfQuery, String queryObjName) {
HashSet<String> rdfUrls = new HashSet<String>();
Query query;
try {
query = QueryFactory.create(rdfQuery);
} catch (QueryParseException qpe) {
logger.warn(
"Could not parse [{}]. Please provide a relevant query. {}",
rdfQuery,
qpe.getLocalizedMessage());
return null;
}
QueryExecution qExec = QueryExecutionFactory.sparqlService(rdfEndpoint, query);
try {
ResultSet results = qExec.execSelect();
while (results.hasNext()) {
QuerySolution sol = results.nextSolution();
try {
String value = sol.getResource(queryObjName).toString();
rdfUrls.add(value);
} catch (NoSuchElementException e) {
logger.error("Encountered a NoSuchElementException: " + e.getLocalizedMessage());
return null;
}
}
} catch (Exception e) {
logger.error(
"Encountered a [{}] while querying the endpoint for sync", e.getLocalizedMessage());
return null;
} finally {
qExec.close();
}
return rdfUrls;
}