org.openrdf.query.Query Java Examples

/**
 * Rewrite a given query to add inference.
 *
 * @param ql the query language used for the query
 * @param query the query to rewrite
 * @param baseuri a base URI to use for the query
 * @return rewritten query that includes inference
 * @throws MalformedQueryException if the query is malformed
 * @throws RepositoryException if there was a problem while rewriting
 */
public Query rewrite(QueryLanguage ql, String query, String baseuri)
		throws MalformedQueryException, RepositoryException {
	// parse query using Sesame
	QueryParserFactory f = QueryParserRegistry.getInstance().get(ql);
	QueryParser parser = f.getParser();
	ParsedQuery parsed = parser.parseQuery(query, baseuri);
	// get SPARQL algebra expression from parsed query
	TupleExpr expr = parsed.getTupleExpr();
	// rewrite query using visitor pattern
	RuleTransformationVisitor visitor
			= new RuleTransformationVisitor(rules);
	expr.visit(visitor);
	// return new query based on rewritten algebra expression
	return getExprQuery(parsed, expr);
}
 

public List<List<Object>> evaluate(String queries) throws Exception {
	List<List<Object>> report = new ArrayList<List<Object>>();
			
	List<String> qnames = Arrays.asList(queries.split(" "));
	for (String curQueryName : qnames)
	{
		List<Object> reportRow = new ArrayList<Object>();
		report.add(reportRow);
		String curQuery = qp.getQuery(curQueryName);
		reportRow.add(curQueryName);
		
		long startTime = System.currentTimeMillis();
		//ParsedOperation pO = QueryParserUtil.parseOperation(QueryLanguage.SPARQL, curQuery, null);
		RepositoryConnection repCon = this.repository.getConnection();
		try {
			Query tempq = repCon.prepareQuery(QueryLanguage.SPARQL, curQuery);
			TupleQuery q = (TupleQuery)tempq;
			
			SyncTupleQueryResultHandler rhandler = new SyncTupleQueryResultHandler();
            q.evaluate(rhandler);
            		
		    long runTime = System.currentTimeMillis() - startTime;
		    reportRow.add((Long)rhandler.resultCount); reportRow.add((Long)runTime);

		    log.info(curQueryName + ": Query exection time (msec): "+ runTime + ", Total Number of Records: " + rhandler.resultCount);
		} catch (Exception e) {
			reportRow.add(null); reportRow.add(null);
		} finally {
			repCon.close();
        }
	}
	return report;
}
 

@Override
public Query prepareQuery(String sparqlQuery) {
	try {
		return conn.prepareQuery(QueryLanguage.SPARQL, sparqlQuery);
	} catch (RepositoryException | MalformedQueryException e) {
		e.printStackTrace();
		throw new SparqlTutorialException(e);
	}
}
 

@Override
public Query prepareQuery(final QueryLanguage ql, final String query,
        final String baseURI) throws RepositoryException,
        MalformedQueryException {

    return prepareQuery(ql, query);

}
 

/**
 * Creates a new query based on a tuple expression and original query. The
 * new query will have the same type null
 * ({@link org.openrdf.query.TupleQuery},
 * {@link org.openrdf.query.GraphQuery} or
 * {@link org.openrdf.query.BooleanQuery}) as the given original query.
 *
 * @param orig the original query
 * @param expr the expression used for the new query
 * @return new query based on expression
 */
protected Query getExprQuery(ParsedQuery orig, TupleExpr expr) {
	if (orig instanceof ParsedTupleQuery) {
		return new SailTupleExprQuery(
				new ParsedTupleQuery(expr), conn);
	} else if (orig instanceof ParsedGraphQuery) {
		return new SailGraphExprQuery(
				new ParsedGraphQuery(expr), conn);
	} else {
		return new SailBooleanExprQuery(
				new ParsedBooleanQuery(expr), conn);
	}
}
 

/**
 * Utility function to set the Query timeout to the global
 * setting if it is configured.
 */
protected void setMaxQueryTime(final Query query) {
    if (maxQueryTime > 0) {
        query.setMaxQueryTime(maxQueryTime);
    }
}
 

@Override
   public Query prepareQuery(final QueryLanguage ql, final String query)
           throws RepositoryException, MalformedQueryException {

	throw new UnsupportedOperationException("please use the specific operation for your query type: prepare[Boolean/Tuple/Graph]Query");
	
}
 

/**
 * Rewrite a given query to add inference.
 *
 * @param ql the query language used for the query
 * @param query the query to rewrite
 * @return rewritten query that includes inference
 * @throws MalformedQueryException if the query is malformed
 * @throws RepositoryException if there was a problem while rewriting
 */
public Query rewrite(QueryLanguage ql, String query)
		throws MalformedQueryException, RepositoryException {
	return rewrite(ql, query, null);
}
 

Query prepareQuery(String sparqlQuery);