public ConjunctiveQuery(Query q) { if (!q.isSelectType()) { throw new RuntimeException("A conjunctive query can only be created from a select query: "+q.serialize(Syntax.syntaxSPARQL_11)); } query = q; setQueryPattern(q.getQueryPattern()); }
public QueryResultTableImpl(Query query, Dataset jenaDataset) throws ModelRuntimeException { if(!query.isSelectType()) { throw new ModelRuntimeException("The given query is not a SELECT query"); } // else this.varnames = new ArrayList<String>(); for(Object o : query.getResultVars()) { this.varnames.add((String)o); } this.qexec = QueryExecutionFactory.create(query, jenaDataset); }
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" ; return "<<unknown>>" ; }
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 ConjunctiveQuery() { query = new Query(); query.setQuerySelectType(); } public ConjunctiveQuery(Query q) {
String query(String query) { LOGGER.info("Using JENA:"); Query q=QueryFactory.create(query); LOGGER.info("-- Query:\n"+q); LOGGER.info("-- Base: "+q.getBaseURI()); LOGGER.info("-- Prefixes: "+q.getPrefixMapping()); LOGGER.info("-- Variables: "+q.getProjectVars()); Set<Var> variables=new HashSet<Var>(q.getProjectVars()); for(Entry<Var, Expr> entry:q.getProject().getExprs().entrySet()) { Var shadowing = entry.getKey(); VariableShadowingDetector detector = new VariableShadowingDetector(new IndentUtils(),shadowing); entry.getValue().visit(detector); if(detector.isShadowing()) { variables.remove(shadowing); variables.add(detector.getShadowed()); } } LOGGER.info("-- Graph URIS: "+q.getGraphURIs()); LOGGER.info("-- Named graphd URIS: "+q.getNamedGraphURIs()); List<String> search=q.getNamedGraphURIs(); q.getQueryPattern().visit(new ElementVisitorImplementation(search,variables)); return null; }
public Query parse(com.hp.hpl.jena.query.Query sparql, KnowledgeBase kb) { this.kb = kb; if( sparql.isDescribeType() ) throw new UnsupportedQueryException( "DESCRIBE queries cannot be answered with PelletQueryEngine" ); final Element pattern = sparql.getQueryPattern(); sparql.setResultVars(); return parse( triples, sparql.getResultVars(), kb, sparql.isDistinct() );
private void execute(String queryString) { this.prefixes = new LinkedList<Prefix>(); List<Term> ans = new LinkedList<Term>(); Query sparql = QueryFactory.create(queryString); for (Map.Entry<String, String> e : sparql.getPrefixMapping().getNsPrefixMap().entrySet()) { this.prefixes.add(new Prefix(e.getKey(), e.getValue())); } if (sparql.isSelectType()) { for (String v : sparql.getResultVars()) { ans.add(DefaultTermFactory.instance().createVariable(v)); } } ElementVisitorImpl visitor = new ElementVisitorImpl(DefaultAtomSetFactory.instance().create()); sparql.getQueryPattern().visit(visitor); // check if answer variables appear in the query body Set<Variable> bodyVars = visitor.getAtomSet().getVariables(); for(Term t : ans) { if(t.isVariable() && !bodyVars.contains(t)) { throw new ParseError("The variable ["+ t +"] of the answer list does not appear in the query body."); } } this.query = DefaultConjunctiveQueryFactory.instance().create(visitor.getAtomSet(), ans); }
Query convert() { if (hasRun) { return this.query; } else { try { op.visit(this) ; Collection<Var> vars = this.projectVars; query.setQueryResultStar(vars.isEmpty()); // SELECT * unless we are projecting Iterator<Var> iter = vars.iterator(); for (; iter.hasNext();) { Var var = iter.next(); if (this.varExpression.containsKey(var)) query.addResultVar(var, this.varExpression.get(var)); else query.addResultVar(var); } ElementGroup eg = this.currentGroup ; query.setQueryPattern(eg) ; query.setQuerySelectType() ; query.setResultVars() ; // Variables from the group. return query ; } finally { this.hasRun = true; } } }
private void execute(String sparqlQuery) { Query sparql = QueryFactory.create(sparqlQuery); this.prefixes = new LinkedList<Prefix>(); for(Map.Entry<String,String> e : sparql.getPrefixMapping().getNsPrefixMap().entrySet()) { this.prefixes.add(new Prefix(e.getKey(), e.getValue())); } Rule rule = new DefaultRule(); if (sparql.isConstructType()) { Template template = sparql.getConstructTemplate(); for (Triple triple : template.getTriples()) { rule.getHead().add(SparqlUtils.triple2Atom(triple)); } } ElementVisitorImpl visitor = new ElementVisitorImpl(rule.getBody()); sparql.getQueryPattern().visit(visitor); this.rule = rule; }
public void visitSelectResultForm(Query query1) { check("Not both SELECT queries", query2.isSelectType()) ; check("DISTINCT modifier", query1.isDistinct() == query2.isDistinct()) ; check("SELECT *", query1.isQueryResultStar() == query2.isQueryResultStar()) ; check("Result variables", query1.getProject(), query2.getProject() ) ; }
public QueryEngineHTTP(String serviceURI, Query query) { this(serviceURI, query.toString()) ; }
public static <T extends ResourceObject> Query evaluate(QueryServiceConfiguration queryServiceDTO, URI rootType) throws ParseException { Query query = QueryFactory.make(); query.setQuerySelectType(); ElementGroup elementGroup = new ElementGroup(); Var objectVar = Var.alloc("root"); // Creating and adding the first triple - could be something like: "?objectVar rdf:type oa:Annotation Triple t1 = new Triple(objectVar, RDF.type.asNode(), NodeFactory.createURI(rootType.toString())); elementGroup.addTriplePattern(t1); // Evaluating the criteria for (Criteria c : queryServiceDTO.getCriteria()) { SesameValueBackend backend = new SesameValueBackend(); LdPathParser parser = new LdPathParser(backend, queryServiceDTO.getConfiguration(), new StringReader(c.getLdpath())); Var var = LDPathEvaluator.evaluate(parser.parseSelector(queryServiceDTO.getPrefixes()), elementGroup, objectVar, queryServiceDTO.getEvaluatorConfiguration()); if (c.getConstraint() != null) { String resolvedConstraint = resolveConstraintPrefix(c.getConstraint(), queryServiceDTO, parser); EvalComparison.evaluate(elementGroup, c, var, resolvedConstraint); } } // Adding all generated patterns to the query object query.setQueryPattern(elementGroup); // Choose what we want so select - SELECT ?annotation in this case query.addResultVar(objectVar); // Setting the default prefixes, like rdf: or dc: query.getPrefixMapping().setNsPrefixes(queryServiceDTO.getPrefixes()); return query; }
private void findAndAddNamedVars() { Iterator<Var> varIter = null ; if ( hasGroupBy() ) varIter = groupVars.getVars().iterator() ; else { // Binding variables -- in patterns, not in filters and not in EXISTS LinkedHashSet<Var> queryVars = new LinkedHashSet<Var>() ; PatternVars.vars(queryVars, this.getQueryPattern()) ; if ( this.hasBindings() ) queryVars.addAll(getBindingVariables()) ; varIter = queryVars.iterator() ; } // All query variables, including ones from bNodes in the query. for ( ; varIter.hasNext() ; ) { Object obj = varIter.next() ; //Var var = (Var)iter.next() ; Var var = (Var)obj ; if ( var.isNamedVar() ) addResultVar(var) ; } }
private void findAndAddNamedVars() { Iterator<Var> varIter = null ; if ( hasGroupBy() ) varIter = groupVars.getVars().iterator() ; else { // Binding variables -- in patterns, not in filters and not in EXISTS LinkedHashSet<Var> queryVars = new LinkedHashSet<Var>() ; PatternVars.vars(queryVars, this.getQueryPattern()) ; if ( this.hasValues() ) queryVars.addAll(getValuesVariables()) ; // if ( this.hasValues() ) // queryVars.addAll(getValuesVariables()) ; varIter = queryVars.iterator() ; } // All query variables, including ones from bNodes in the query. for ( ; varIter.hasNext() ; ) { Object obj = varIter.next() ; //Var var = (Var)iter.next() ; Var var = (Var)obj ; if ( var.isNamedVar() ) addResultVar(var) ; } }
public void visitDescribeResultForm(Query query1) { check("Not both DESCRIBE queries", query2.isDescribeType()) ; check("Result variables", query1.getResultVars(), query2.getResultVars() ) ; check("Result URIs", query1.getResultURIs(), query2.getResultURIs() ) ; }
public void visitQueryPattern(Query query) { if ( query.getQueryPattern() != null ) x ^= query.getQueryPattern().hashCode() ; }
@Override protected Query parse$(Query q, String s) q.setSyntax(Syntax.syntaxRDQL) ; PrefixMapping pm = new PrefixMapping2(ARQConstants.getGlobalPrefixMap(), q.getPrefixMapping()) ; q.setPrefixMapping(pm) ; q.getPrefixMapping().setNsPrefixes(ARQConstants.getGlobalPrefixMap()) ; Q_Query query = null ; try { if ( q.getGraphURIs() != null ) for ( int i = 0 ; i < q.getGraphURIs().size() ; i++ ) String u = q.getGraphURIs().get(i) ; u = q.getResolver().resolve(u) ; q.getGraphURIs().set(i, u) ;
public Query simplify(Query q) { QueryPatternSimplification qps = new QueryPatternSimplification(); q.getQueryPattern().visit(qps); Element newelt = qps.getResult(); Query ret = q.cloneQuery(); ret.setQueryPattern(newelt); return ret; }
public static Element parseElement(String string) { final Query query = new Query () ; Action action = new Action() { public void exec(SPARQLParser11 parser) throws Exception { Element el = parser.GroupGraphPattern() ; query.setQueryPattern(el) ; } } ; perform(query, string, action) ; return query.getQueryPattern() ; }