/** * Extracts any {@code SortCondition} instances from the SPARQL query and holds them in an index of their keys * where the value is that keys sorting direction. */ private static Map<String, Order> createOrderIndexFromQuery(final Query query) { final Map<String, Order> orderingIndex = new HashMap<>(); if (query.hasOrderBy()) { final List<SortCondition> sortingConditions = query.getOrderBy(); for (SortCondition sortCondition : sortingConditions) { final Expr expr = sortCondition.getExpression(); // by default, the sort will be ascending. getDirection() returns -2 if the DESC/ASC isn't // supplied - weird orderingIndex.put(expr.getVarName(), sortCondition.getDirection() == -1 ? Order.decr : Order.incr); } } return orderingIndex; }
/** * Converts SPARQL to a Gremlin traversal. * * @param g the {@link GraphTraversalSource} instance to execute the traversal from * @param sparqlQuery the query to compile to Gremlin */ public static GraphTraversal<Vertex, ?> compile(final GraphTraversalSource g, final String sparqlQuery) { return compile(g, QueryFactory.create(Prefixes.prepend(sparqlQuery), Syntax.syntaxSPARQL)); }
public Model retrieveModel(String graphName) { String queryTemplate = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH ?g { ?s ?p ?o } . }"; ParameterizedSparqlString pps = new ParameterizedSparqlString(); pps.setCommandText(queryTemplate); pps.setIri("g", graphName); Query query = QueryFactory.create(pps.toString()); QueryExecution qexec = QueryExecutionFactory.sparqlService(sparqlEndpoint, query); Model model = qexec.execConstruct(); return model; }
public static int count(String queryStr, DatasetGraph dsg) { int counter = 0 ; Query query = QueryFactory.create(queryStr, Syntax.syntaxARQ) ; try (QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.wrap(dsg))) { ResultSet rs = qExec.execSelect() ; for ( ; rs.hasNext() ; ) { rs.nextBinding() ; counter++ ; } return counter ; } }
private int query(String str, Model model) { Query q = QueryFactory.create(str, Syntax.syntaxARQ) ; try(QueryExecution qexec = QueryExecutionFactory.create(q, model)) { ResultSet rs = qexec.execSelect() ; return ResultSetFormatter.consume(rs) ; } }
private void test(ReadWrite mode) { ds.begin(mode) ; Query q = QueryFactory.create("SELECT * { { ?s ?p ?o } UNION { GRAPH ?g { ?s ?p ?o }}}") ; QueryExecution qExec = QueryExecutionFactory.create(q, ds) ; long count = ResultSetFormatter.consume(qExec.execSelect()) ; ds.commit() ; ds.end() ; assertEquals(2, count) ; }
public static ResultSet query(String string, Model m, String varName, RDFNode value) { Query query = QueryFactory.create(FusekiConst.PREFIXES + string) ; QuerySolutionMap initValues = null ; if ( varName != null && value != null ) initValues = querySolution(varName, value) ; try ( QueryExecution qExec = QueryExecutionFactory.create(query, m, initValues) ) { return ResultSetFactory.copyResults(qExec.execSelect()) ; } }
private ResultSetRewindable executeSparqlSelect(Model model, String sparql, boolean lock) { Query query = QueryFactory.create(sparql); try(QueryExecution queryExec = QueryExecutionFactory.create(query, model)) { model.enterCriticalSection(lock); try { return ResultSetFactory.makeRewindable(queryExec.execSelect()); } finally { model.leaveCriticalSection(); } } }
final List<String> vars = query.getResultVars(); if (!query.isQueryResultStar() && !query.hasGroupBy()) { final String[] all = new String[vars.size()]; vars.toArray(all); if (query.isDistinct()) { traversal = traversal.dedup(all); if (query.hasGroupBy()) { final VarExprList lstExpr = query.getGroupBy(); String grpVar = ""; for (Var expr : lstExpr.getVars()) { if (query.hasAggregators()) { final List<ExprAggregator> exprAgg = query.getAggregators(); for (ExprAggregator expr : exprAgg) { if (expr.getAggregator().getName().contains("COUNT")) { if (!query.toString().contains("GROUP")) { if (expr.getAggregator().toString().contains("DISTINCT")) traversal = traversal.dedup(expr.getAggregator().getExprList().get(0).toString().substring(1)); if (query.hasOrderBy() && query.hasGroupBy()) orderingIndex.forEach((k, v) -> traversal = traversal.order().by(__.select(k), v)); if (query.hasLimit()) { long limit = query.getLimit(), offset = 0; if (query.hasOffset()) offset = query.getOffset();
/** Create a QueryExecution that will access a SPARQL service over HTTP * @param service URL of the remote service * @param query Query string to execute * @param client HTTP client * @param httpContext HTTP Context * @return QueryExecution */ static public QueryExecution sparqlService(String service, String query, HttpClient client, HttpContext httpContext) { checkNotNull(service, "URL for service is null") ; checkArg(query) ; return sparqlService(service, QueryFactory.create(query), client) ; }
/** Create a QueryExecution to execute over the Model, * given some initial values of variables. * * @param query Query * @param model Target of the query * @param initialBinding Any initial binding of variables * @return QueryExecution */ static public QueryExecution create(Query query, Model model, QuerySolution initialBinding) { checkArg(model) ; return create(query, DatasetFactory.wrap(model), initialBinding) ; }
private static Query toQuery(Element pattern) { Query query = QueryFactory.make() ; query.setQueryPattern(pattern) ; query.setQuerySelectType() ; query.setQueryResultStar(true) ; return query ; }
/** Create a query from the given string by calling the parser. * * @param queryString The query string * @param baseURI Base URI * @throws QueryException Thrown when a parse error occurs */ static public Query create(String queryString, String baseURI) { Query query = new Query() ; return parse(query, queryString, baseURI, Syntax.defaultQuerySyntax) ; }
public void addOrderBy(Expr expr, int direction) { SortCondition sc = new SortCondition(expr, direction) ; addOrderBy(sc) ; }
public static int count(String queryStr, DatasetGraph dsg) { int counter = 0 ; Query query = QueryFactory.create(queryStr, Syntax.syntaxARQ) ; try (QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.wrap(dsg))) { ResultSet rs = qExec.execSelect() ; for ( ; rs.hasNext() ; ) { rs.nextBinding() ; counter++ ; } return counter ; } }
private int count(Dataset dataset, String queryString) { Query query = QueryFactory.create(queryString) ; QueryExecution qExec = QueryExecutionFactory.create(query, dataset) ; ResultSet rs = qExec.execSelect() ; return ResultSetFormatter.consume(rs) ; } private void update(Dataset dataset, String string)
private static void testCount(String queryString, int expected, Dataset ds) { Query query = QueryFactory.create(queryString) ; QueryExecution qExec = QueryExecutionFactory.create(query, ds) ; ResultSet rs = qExec.execSelect() ; int n = ResultSetFormatter.consume(rs) ; assertEquals(expected, n) ; } }