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(); }
private ParsedOperation parseOperation(QueryLanguage ql, String queryString, String baseURI) throws RepositoryException { ParsedOperation parsedQuery; try { QueryParser parser = createParser(ql); try { parsedQuery = parser.parseQuery(queryString, baseURI); } catch (MalformedQueryException e) { try { parsedQuery = parser.parseUpdate(queryString, baseURI); } catch (MalformedQueryException u) { throw new RepositoryException(e); } } } catch (UnsupportedQueryLanguageException e) { throw new RepositoryException(e); } return parsedQuery; }
private List<Rule> parse(String rulesString) throws Exception { String[] rules = rulesString.split("###"); List<Rule> result = new LinkedList<Rule>(); for (String rule : rules) { SPARQLParserFactory fac = new SPARQLParserFactory(); QueryParser parser = fac.getParser(); ParsedQuery query = parser.parseQuery(rule, null); Rule r = new Rule(query); result.add(r); } return result; }
@Override public QueryType getQueryType(QueryLanguage language, String query) throws MalformedQueryException { QueryParser parser = QueryParserUtil.createParser(language); ParsedQuery parsedQuery = parser.parseQuery(query, configurationService.getServerUri() + SparqlWebService.PATH + "/" + SparqlWebService.SELECT); if (parsedQuery instanceof ParsedTupleQuery) { return QueryType.TUPLE; } else if (parsedQuery instanceof ParsedBooleanQuery) { return QueryType.BOOL; } else if (parsedQuery instanceof ParsedGraphQuery) { return QueryType.GRAPH; } else { return null; } }
@Override public QueryType getQueryType(QueryLanguage language, String query) throws MalformedQueryException { QueryParser parser = QueryParserUtil.createParser(language); ParsedQuery parsedQuery = parser.parseQuery(query, configurationService.getServerUri() + SparqlWebService.PATH + "/" + SparqlWebService.SELECT); if (parsedQuery instanceof ParsedTupleQuery) { return QueryType.TUPLE; } else if (parsedQuery instanceof ParsedBooleanQuery) { return QueryType.BOOL; } else if (parsedQuery instanceof ParsedGraphQuery) { return QueryType.GRAPH; } else { return null; } }
public String getRewriting(String query) throws OWLException { try { //Query jenaquery = QueryFactory.create(query); QueryParser qp = QueryParserUtil.createParser(QueryLanguage.SPARQL); ParsedQuery pq = qp.parseQuery(query, null); // base URI is null //SparqlAlgebraToDatalogTranslator tr = st.questInstance.getSparqlAlgebraToDatalogTranslator(); //List<String> signatureContainer = tr.getSignature(pq); return st.getRewriting(pq/*, signatureContainer*/); } catch (Exception e) { throw new OntopOWLException(e); } }
@Override public Query prepareQuery(QueryLanguage ql, String query, String baseURI) throws MalformedQueryException, RepositoryException { ParsedQuery parsedQuery = createParser(ql).parseQuery(query, baseURI); if (parsedQuery instanceof ParsedBooleanQuery) return prepareBooleanQuery(ql, query, baseURI); if (parsedQuery instanceof ParsedGraphQuery) return prepareGraphQuery(ql, query, baseURI); if (parsedQuery instanceof ParsedTupleQuery) return prepareTupleQuery(ql, query, baseURI); throw new MalformedQueryException("Unsupported qurey type: " + parsedQuery.getClass()); }
public String rewrite(String selectQuery) throws Exception { SPARQLParserFactory fac = new SPARQLParserFactory(); QueryParser parser = fac.getParser(); ParsedTupleQuery query = (ParsedTupleQuery) parser.parseQuery(selectQuery, null); resolutionEngine.unfold(query); SPARQLQueryRenderer renderer = new SPARQLQueryRenderer(); String renderedQuery = renderer.render(query); return renderedQuery; }
@Override protected void runTest() throws Exception { // Read query from file InputStream stream = url(queryFile).openStream(); String query = IOUtil.readString(new InputStreamReader(stream, "UTF-8")); stream.close(); try { QueryParser parser = createParser(); parser.parseQuery(query, null); if (MFX_PARSE_ERROR.equals(result)) { fail("Negative syntax test failed. Malformed query caused no error."); } } catch (MalformedQueryException e) { if (MFX_CORRECT.equals(result)) { fail("Positive syntax test failed: " + e.getMessage()); } else { return; } } }
/** * 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); }