Refine search
static private String labelForQuery(Query q) { if ( q.isSelectType() ) return "SELECT" ; if ( q.isConstructType() ) return "CONSTRUCT" ; if ( q.isDescribeType() ) return "DESCRIBE" ; if ( q.isAskType() ) return "ASK" ; if ( q.isJsonType() ) return "JSON" ; return "<<unknown>>" ; }
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()) { grpVar = expr.getName(); 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();
@Deprecated // Remove once countQuery works as espected public static long countQueryOld(Query query, QueryExecutionFactory qef) { Var outputVar = Var.alloc("_c_"); if(query.isConstructType()) { Element element = query.getQueryPattern(); query = new Query(); query.setQuerySelectType(); query.setQueryResultStar(true); query.setQueryPattern(element); } Query countQuery = QueryFactory.create("Select (Count(*) As ?_c_) { {" + query + "} }", Syntax.syntaxSPARQL_11); QueryExecution qe = qef.createQueryExecution(countQuery); ResultSet rs = qe.execSelect(); Binding binding = rs.nextBinding(); Node node = binding.get(outputVar); Number numeric = (Number)node.getLiteralValue(); long result = numeric.longValue(); return result; }
protected Query elementToQuery(Element pattern) { if ( pattern == null ) return null; Query query = new Query(); query.setQueryPattern(pattern); query.setQuerySelectType(); query.setQueryResultStar(true); query.setResultVars(); return query; }
public static long adjustPageSize(QueryExecutionFactory factory, long requestedPageSize) { Query query = CannedQueryUtils.spoTemplate(); query.setLimit(requestedPageSize); //System.out.println(query); QueryExecution qe = factory.createQueryExecution(query); ResultSet rs = qe.execSelect(); long size = 0; while(rs.hasNext()) { ++size; rs.next(); } size = Math.max(size, 1); qe.close(); return size >= requestedPageSize ? requestedPageSize : size; } }
private static List<RDFNode> creatingAgentsFor(Resource r) { logger.fine("Finding creator of " + r); String queryStr = sparqlPrefixes + "SELECT ?agent WHERE { \n" + " { \n" + " ?r dct:creator [ \n" + " rdfs:member ?agent \n" + " ] \n" + " } UNION { \n" + " ?r dct:creator ?agent .\n " + " FILTER NOT EXISTS { ?agent rdfs:member ?member } \n" + " } \n" + "} \n"; logger.finer(QueryFactory.create(queryStr).toString()); QueryExecution qexec = QueryExecutionFactory.create(queryStr, r.getModel()); QuerySolutionMap binding = new QuerySolutionMap(); binding.add("r", r); qexec.setInitialBinding(binding); ResultSet select = qexec.execSelect(); List<RDFNode> agents = new ArrayList<>(); while (select.hasNext()) { RDFNode agent = select.next().get("agent"); logger.fine("Found: " + agent); agents.add(agent); } return agents; }
public static Query spoCountTemplate(Node s, Node p, Node o) { Query query = QueryFactory.create(); query.setQuerySelectType(); Triple triple = new Triple(s, p, o); ElementGroup group = new ElementGroup(); group.addTriplePattern(triple); query.setQueryPattern(group); if(s.isVariable()) { query.getProject().add(Var.alloc(s.getName())); } if(p.isVariable()) { query.getProject().add(Var.alloc(p.getName())); } if(o.isVariable()) { query.getProject().add(Var.alloc(o.getName())); } query.allocAggregate(new AggCount()); return query; }
/** * Execute a SELECT query and process the rows of the results with the handler code. * @param query * @param rowAction */ @Override public default void querySelect(Query query, Consumer<QuerySolution> rowAction) { if ( ! query.isSelectType() ) throw new JenaConnectionException("Query is not a SELECT query"); Txn.executeRead(this, ()->{ try ( QueryExecution qExec = query(query) ) { qExec.execSelect().forEachRemaining(rowAction); } } ); }
public static Query createQueryCount(Var countVar, Element e, Long limit) { if(limit != null) { e = limitElement(e, limit); } Var tmpVar = Var.alloc(countVar.getName() + "_tmp_"); Query result = new Query(); result.setQuerySelectType(); result.getProject().add(countVar, new ExprAggregator(tmpVar, new AggCount())); result.setQueryPattern(e); return result; }
public QueryRunner trySelect(String queryString) { Stopwatch sw = Stopwatch.createStarted(); Query query = new Query(); query.setPrefixMapping(prefixMapping); QueryFactory.parse(query, queryString, "http://example.org/", syntax); QueryExecution qe = sparqlService.createQueryExecution(query); ResultSet rs = qe.execSelect(); ResultSetFormatter.consume(rs); System.out.println("Time taken: " + sw.elapsed(TimeUnit.MILLISECONDS)); return this; } }
private static void test3(String pattern, String... joinForm) { Query q = QueryFactory.create("PREFIX : <http://example/> SELECT * "+pattern) ; Op op = Algebra.compile(q.getQueryPattern()) ; test(op, joinForm) ; }
private QueryExecution queryExec(Query query, String queryString) { checkQuery(); if ( query == null && queryString == null ) throw new InternalErrorException("Both query and query string are null"); if ( query == null ) { if ( parseCheckQueries ) QueryFactory.create(queryString); } // Use the query string as provided if possible, otherwise serialize the query. String queryStringToSend = ( queryString != null ) ? queryString : query.toString(); return exec(()-> createQueryExecution(query, queryStringToSend)); }
private void processResults(TarqlQueryExecution ex) throws IOException { if (testQuery && ex.getFirstQuery().getConstructTemplate() != null) { IndentedWriter out = new IndentedWriter(System.out); new FmtTemplate(out, new SerializationContext(ex.getFirstQuery())).format(ex.getFirstQuery().getConstructTemplate()); out.flush(); } if (ex.getFirstQuery().isSelectType()) { System.out.println(ResultSetFormatter.asText(ex.execSelect())); } else if (ex.getFirstQuery().isAskType()) { System.out.println(ResultSetFormatter.asText(ex.execSelect())); } else if (ex.getFirstQuery().isConstructType()) { resultTripleIterator = resultTripleIterator.andThen(ex.execTriples()); } else { cmdError("Only query forms CONSTRUCT, SELECT and ASK are supported"); } }
/** Return a closable resultset for a {@link QueryExecution}. * The {@link QueryExecution} must be for a {@code SELECT} query. * @param queryExecution {@code QueryExecution} must be for a {@code SELECT} query. * @return ResultSetCloseable */ public static ResultSetCloseable closeableResultSet(QueryExecution queryExecution) { if ( queryExecution.getQuery() != null && ! queryExecution.getQuery().isSelectType() ) throw new IllegalArgumentException("Not an execution for a SELECT query"); return new ResultSetCloseable(queryExecution.execSelect(), queryExecution) ; }
public static void executeQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat) { Query query = queryExecution.getQuery() ; if ( prologue == null ) prologue = query.getPrologue() ; if ( prologue == null ) prologue = dftPrologue ; if ( query.isSelectType() ) doSelectQuery(prologue, queryExecution, outputFormat) ; else if ( query.isDescribeType() ) doDescribeQuery(prologue, queryExecution, outputFormat) ; else if ( query.isConstructQuad() ) // Before isConstructType. doConstructQuadsQuery(prologue, queryExecution, outputFormat) ; else if ( query.isConstructType() ) doConstructQuery(prologue, queryExecution, outputFormat) ; else if ( query.isAskType() ) doAskQuery(prologue, queryExecution, outputFormat) ; else if ( query.isJsonType() ) doJsonQuery(prologue, queryExecution, outputFormat) ; else throw new QueryException("Unrecognized query form"); }
/** * Makes a copy of this query. Copies by parsing a query from the serialized form of this query * @return Copy of this query */ public Query cloneQuery() { // A little crude. // Must use toString() rather than serialize() because we may not know how to serialize extended syntaxes String qs = this.toString(); return QueryFactory.create(qs, getSyntax()) ; }
/** * Execute a SELECT query and process the ResultSet with the handler code. * @param query * @param resultSetAction */ @Override public default void queryResultSet(Query query, Consumer<ResultSet> resultSetAction) { if ( ! query.isSelectType() ) throw new JenaConnectionException("Query is not a SELECT query"); Txn.executeRead(this, ()->{ try ( QueryExecution qExec = query(query) ) { ResultSet rs = qExec.execSelect(); resultSetAction.accept(rs); } } ); }
public static Element limitElement(Element e, long limit) { Query subQuery = new Query(); subQuery.setQuerySelectType(); subQuery.setQueryResultStar(true); subQuery.setQueryPattern(e); subQuery.setLimit(limit); Element result = new ElementSubQuery(subQuery); return result; }
public static Node extractDescribeNode(Query query) { if (!query.isDescribeType()) { throw new RuntimeException("DESCRIBE query expected. Got: [" + query.toString() + "]"); } // TODO Right now we only support describe with a single constant. //Element queryPattern = query.getQueryPattern(); if(query.getQueryPattern() != null || !query.getResultVars().isEmpty() || query.getResultURIs().size() > 1) { throw new RuntimeException("Sorry, DESCRIBE is only implemented for a single resource argument"); } Node result = query.getResultURIs().get(0); return result; }
/** * Execute a query, expecting the result to be one row, one column. Return * that one RDFNode */ public static RDFNode getExactlyOne(String qs, Dataset ds) { Query q = QueryFactory.create(qs) ; if ( q.getResultVars().size() != 1 ) throw new ARQException("getExactlyOne: Must have exactly one result columns") ; String varname = q.getResultVars().get(0) ; try ( QueryExecution qExec = QueryExecutionFactory.create(q, ds) ) { return getExactlyOne(qExec, varname) ; } }