/** * Render the ParsedQuery as a query string * * @param theQuery * the parsed query to render * @return the query object rendered in the serql syntax * @throws Exception * if there is an error while rendering */ public String render(ParsedQuery theQuery) throws Exception { return render(theQuery.getTupleExpr()); }
/** * Finds the first {@link Projection} node within a {@link ParsedQuery}. * * @param query - The query that will be searched. (not null) * @return The first projection encountered if the query has one; otherwise absent. */ public Optional<Projection> findProjection(final ParsedQuery query) { checkNotNull(query); // When a projection is encountered for the requested index, store it in atomic reference and quit searching. final AtomicReference<Projection> projectionRef = new AtomicReference<>(); query.getTupleExpr().visit(new QueryModelVisitorBase<RuntimeException>() { @Override public void meet(Projection projection) { projectionRef.set(projection); } }); return Optional.fromNullable( projectionRef.get() ); } }
protected TupleExpr loadQuery(final String fileName) throws Exception { InputStream in = RDFStreamProcessor.class.getResourceAsStream(fileName); String query = IOUtil.readString(in); in.close(); ParsedQuery pq = queryParser.parseQuery(query, BASE_IRI); return pq.getTupleExpr(); }
public static TupleExpr parseTupleExpr(final String string, @Nullable final String baseURI, @Nullable final Map<String, String> namespaces) throws MalformedQueryException { Objects.requireNonNull(string); final TupleExpr expr = ((Projection) parseQuery("SELECT *\nWHERE {\n" + string + "\n}", baseURI, namespaces).getTupleExpr()).getArg(); expr.setParentNode(null); return expr; }
public static ValueExpr parseValueExpr(final String string, @Nullable final String baseURI, @Nullable final Map<String, String> namespaces) throws MalformedQueryException { Objects.requireNonNull(string); final TupleExpr expr = parseQuery("SELECT ((" + string + ") AS ?dummy) WHERE {}", baseURI, namespaces).getTupleExpr(); return ((Extension) ((Projection) expr).getArg()).getElements().get(0).getExpr(); }
/** * @inheritDoc */ public String render(final ParsedQuery theQuery) throws Exception { mRenderer.reset(); return mRenderer.render(theQuery.getTupleExpr()); } }
@Override public String render(final ParsedQuery query) { return render(query.getTupleExpr(), query.getDataset()); }
@Override public String render(final ParsedQuery query) { return render(query.getTupleExpr(), query.getDataset()); }
/** * Get the first {@link Projection} node from a SPARQL query. * * @param sparql - The query that contains a single Projection node. * @return The first {@link Projection} that is encountered. * @throws Exception The query could not be parsed. */ public static @Nullable Projection getProjection(final String sparql) throws Exception { requireNonNull(sparql); final AtomicReference<Projection> projection = new AtomicReference<>(); final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null); parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() { @Override public void meet(final Projection node) throws Exception { projection.set(node); } }); return projection.get(); }
/** * Get the first {@link Filter} node from a SPARQL query. * * @param sparql - The query that contains a single Projection node. * @return The first {@link Filter} that is encountered. * @throws Exception The query could not be parsed. */ public static @Nullable Filter getFilter(final String sparql) throws Exception { requireNonNull(sparql); final AtomicReference<Filter> filter = new AtomicReference<>(); final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null); parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() { @Override public void meet(final Filter node) throws Exception { filter.set(node); } }); return filter.get(); } }
/** * Get the first {@link MultiProjection} node from a SPARQL query. * * @param sparql - The query that contains a single Projection node. * @return The first {@link MultiProjection} that is encountered. * @throws Exception The query could not be parsed. */ public static @Nullable MultiProjection getMultiProjection(final String sparql) throws Exception { requireNonNull(sparql); final AtomicReference<MultiProjection> multiProjection = new AtomicReference<>(); final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null); parsed.getTupleExpr().visit(new QueryModelVisitorBase<Exception>() { @Override public void meet(final MultiProjection node) throws Exception { multiProjection.set(node); } }); return multiProjection.get(); }
/** * Fetch the {@link StatementPattern} from a SPARQL string. * * @param sparql - A SPARQL query that contains only a single Statement Patern. (not nul) * @return The {@link StatementPattern} that was in the query, if it could be found. Otherwise {@code null} * @throws Exception The statement pattern could not be found in the parsed SPARQL query. */ public static @Nullable StatementPattern getSp(final String sparql) throws Exception { requireNonNull(sparql); final AtomicReference<StatementPattern> statementPattern = new AtomicReference<>(); final ParsedQuery parsed = new SPARQLParser().parseQuery(sparql, null); parsed.getTupleExpr().visitChildren(new QueryModelVisitorBase<Exception>() { @Override public void meet(final StatementPattern node) throws Exception { statementPattern.set(node); } }); return statementPattern.get(); }
@Override protected SparqlQuery parseQuery(String queryStr) throws InvalidQueryException, IncompatibleQueryException { // TODO String baseIRI = "http://example.org/baseIRI"; ParsedQuery parsedQuery; try { parsedQuery = QueryParserUtil.parseQuery( QueryLanguage.SPARQL, queryStr, baseIRI); } catch (MalformedQueryException e) { throw new InvalidQueryException(e); } return new SparqlQuery(parsedQuery.getTupleExpr()); }
private TupleExpr getTupleExpr(ParsedQuery query) { TupleExpr tupleExpr = query.getTupleExpr(); if (tupleExpr instanceof Projection) { Projection proj = (Projection) tupleExpr; for (ProjectionElem e : proj.getProjectionElemList().getElements()) { if (!e.getSourceName().equals(e.getTargetName())) return proj; } return proj.getArg(); } return tupleExpr; }
/** * Converts a SPARQL query consisting of a single Filter clause back to a Filter. * @param sparql - SPARQL query representing a Filter * @return - parsed Filter included in the SPARQL query * @throws FilterParseException */ public static Filter deserialize(String sparql) throws FilterParseException { try { ParsedQuery pq = parser.parseQuery(sparql, null); FilterVisitor visitor = new FilterVisitor(); pq.getTupleExpr().visit(visitor); Set<Filter> filters = visitor.getFilters(); if(filters.size() != 1) { throw new FilterParseException("Filter String must contain only one Filter."); } return filters.iterator().next(); } catch (Exception e) { throw new FilterParseException("Unable to parse Filter.", e); } }
public static synchronized CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluateQuery(final ParsedQuery query, final SailConnection sc) throws QueryException { MapBindingSet bindings = new MapBindingSet(); boolean includeInferred = false; try { return sc.evaluate(query.getTupleExpr(), query.getDataset(), bindings, includeInferred); } catch (SailException e) { throw new QueryException(e); } }
public static Optional<PeriodicQueryNode> getPeriodicNode(String sparql) throws MalformedQueryException { TupleExpr te = new SPARQLParser().parseQuery(sparql, null).getTupleExpr(); PeriodicQueryNodeVisitor periodicVisitor = new PeriodicQueryNodeVisitor(); te.visit(periodicVisitor); return periodicVisitor.getPeriodicNode(); }
public CloseableIteration<BindingSet, QueryEvaluationException> queryDocIndex(final String sparqlQuery, final Collection<BindingSet> constraints) throws TableNotFoundException, QueryEvaluationException { final SPARQLParser parser = new SPARQLParser(); ParsedQuery pq1 = null; try { pq1 = parser.parseQuery(sparqlQuery, null); } catch (final MalformedQueryException e) { e.printStackTrace(); throw new QueryEvaluationException("Malformed query. query=" + sparqlQuery, e); } final TupleExpr te1 = pq1.getTupleExpr(); final List<StatementPattern> spList1 = StatementPatternCollector.process(te1); if(StarQuery.isValidStarQuery(spList1)) { final StarQuery sq1 = new StarQuery(spList1); return queryDocIndex(sq1, constraints); } else { throw new IllegalArgumentException("Invalid star query!"); } }
private Collection<BindingSet> evaluate(final String queryStr) { BindingSet bindings = new EmptyBindingSet(); String baseURI = "http://example.org/baseUri#"; ParsedQuery query; CloseableIteration<? extends BindingSet, QueryEvaluationException> results; query = parser.parseQuery(queryStr, baseURI); Collection<BindingSet> coll = new LinkedList<>(); results = sc.evaluate(query.getTupleExpr(), query.getDataset(), bindings, false); try { while (results.hasNext()) { coll.add(results.next()); } } finally { results.close(); } return coll; }
@Override public Query prepareQuery(QueryLanguage ql, String queryString, String baseURI) throws MalformedQueryException, RepositoryException { ParsedQuery parsedQuery = QueryParserUtil.parseQuery(ql, queryString, baseURI); if (parsedQuery instanceof ParsedGraphQuery) { GraphQuery query = super.prepareGraphQuery(ql, queryString, baseURI); boolean include = query.getIncludeInferred(); AugurNode node = _factory.createAugurNode(parsedQuery, include); return new AugurGraphQuery(node, query); } else if (parsedQuery instanceof ParsedTupleQuery) { TupleQuery query = super.prepareTupleQuery(ql, queryString, baseURI); boolean include = query.getIncludeInferred(); AugurNode node = _factory.createAugurNode(parsedQuery, include); Set<String> names = parsedQuery.getTupleExpr().getBindingNames(); return new AugurTupleQuery(node, query, names); } return super.prepareQuery(ql, queryString, baseURI); }