@Override public SailQuery prepareQuery(QueryLanguage ql, String queryString, String baseURI) throws MalformedQueryException { ParsedQuery parsedQuery = QueryParserUtil.parseQuery(ql, queryString, baseURI); if (parsedQuery instanceof ParsedTupleQuery) { return new SailTupleQuery((ParsedTupleQuery)parsedQuery, this); } else if (parsedQuery instanceof ParsedGraphQuery) { return new SailGraphQuery((ParsedGraphQuery)parsedQuery, this); } else if (parsedQuery instanceof ParsedBooleanQuery) { return new SailBooleanQuery((ParsedBooleanQuery)parsedQuery, this); } else { throw new RuntimeException("Unexpected query type: " + parsedQuery.getClass()); } }
@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 SailTupleQuery prepareTupleQuery(QueryLanguage ql, String queryString, String baseURI) throws MalformedQueryException { ParsedTupleQuery parsedQuery = QueryParserUtil.parseTupleQuery(ql, queryString, baseURI); return new SailTupleQuery(parsedQuery, this); }
private ParsedOperation parseText(Resource queryResource, IRI queryType, TripleSource store) throws OpenRDFException { Value text = Statements.singleValue(queryResource, SP.TEXT_PROPERTY, store); if (text != null) { if (QUERY_TYPES.contains(queryType)) { return QueryParserUtil.parseQuery(QueryLanguage.SPARQL, text.stringValue(), null); } else if (UPDATE_TYPES.contains(queryType)) { return QueryParserUtil.parseUpdate(QueryLanguage.SPARQL, text.stringValue(), null); } else { throw new MalformedSpinException(String.format("Unrecognised command type: %s", queryType)); } } else { return null; } }
@Override public SailGraphQuery prepareGraphQuery(QueryLanguage ql, String queryString, String baseURI) throws MalformedQueryException { ParsedGraphQuery parsedQuery = QueryParserUtil.parseGraphQuery(ql, queryString, baseURI); return new SailGraphQuery(parsedQuery, this); }
@Override public Update prepareUpdate(QueryLanguage ql, String update, String baseURI) throws RepositoryException, MalformedQueryException { ParsedUpdate parsedUpdate = QueryParserUtil.parseUpdate(ql, update, baseURI); return new AutoCommitUpdate(parsedUpdate, this); }
/** * Parse either a SPARQL QUERY or a SPARQL UPDATE request. * @param operation The request. * @param baseURI The base URI. * * @return The {@link ParsedOperation} */ public ParsedOperation parseOperation(final String operation, final String baseURI) throws MalformedQueryException { final String strippedOperation = QueryParserUtil .removeSPARQLQueryProlog(operation).toUpperCase(); final ParsedOperation parsedOperation; if (strippedOperation.startsWith("SELECT") || strippedOperation.startsWith("CONSTRUCT") || strippedOperation.startsWith("DESCRIBE") || strippedOperation.startsWith("ASK")) { parsedOperation = parseQuery(operation, baseURI); } else { parsedOperation = parseUpdate(operation, baseURI); } return parsedOperation; }
throws MalformedQueryException, SailException customQuery = QueryParserUtil.parseGraphQuery(language, queryText, null); String matcherQuery = matcherText; if (matcherText.trim().isEmpty()) { matcherQuery = CustomGraphQueryInferencerConfig.buildMatcherQueryFromRuleQuery(language, queryText); customMatcher = QueryParserUtil.parseGraphQuery(language, matcherQuery, null); customQuery.getTupleExpr().visit(new AbstractQueryModelVisitor<SailException>() {
@Override public Update prepareUpdate(QueryLanguage ql, String update, String baseURI) throws RepositoryException, MalformedQueryException { ParsedUpdate parsedUpdate = QueryParserUtil.parseUpdate(ql, update, baseURI); return new SailUpdate(parsedUpdate, this); }
/** * Parse either a SPARQL QUERY or a SPARQL UPDATE request. * @param operation The request. * @param baseURI The base URI. * * @return The {@link ParsedOperation} */ public ParsedOperation parseOperation(final String operation, final String baseURI) throws MalformedQueryException { final String strippedOperation = QueryParserUtil .removeSPARQLQueryProlog(operation).toUpperCase(); final ParsedOperation parsedOperation; if (strippedOperation.startsWith("SELECT") || strippedOperation.startsWith("CONSTRUCT") || strippedOperation.startsWith("DESCRIBE") || strippedOperation.startsWith("ASK")) { parsedOperation = parseQuery(operation, baseURI); } else { parsedOperation = parseUpdate(operation, baseURI); } return parsedOperation; }
@Override protected void runTest() throws Exception { // Read query from file InputStream stream = new URL(queryFileURL).openStream(); String query = IOUtil.readString(new InputStreamReader(stream, "UTF-8")); stream.close(); try { QueryParserUtil.parseQuery(QueryLanguage.SPARQL, query, queryFileURL); if (!positiveTest) { fail("Negative test case should have failed to parse"); } } catch (MalformedQueryException e) { if (positiveTest) { e.printStackTrace(); fail("Positive test case failed: " + e.getMessage()); } } }
protected int countQueryResults(String query) throws Exception { ParsedTupleQuery tupleQuery = QueryParserUtil.parseTupleQuery(QueryLanguage.SERQL, query + " using namespace ex = <" + EXAMPLE_NS + ">", null); return countElements(con.evaluate(tupleQuery.getTupleExpr(), null, EmptyBindingSet.getInstance(), false)); }
@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 void validate() throws SailConfigException { super.validate(); if (null == language) { throw new SailConfigException("No query language specified for " + getType() + " Sail."); } if (null == ruleQuery) { throw new SailConfigException("No rule query specified for " + getType() + " Sail."); } else { try { QueryParserUtil.parseGraphQuery(language, ruleQuery, null); } catch (OpenRDFException e) { throw new SailConfigException("Problem occured parsing supplied rule query.", e); } } try { if (matcherQuery.trim().isEmpty()) { matcherQuery = buildMatcherQueryFromRuleQuery(language, ruleQuery); } QueryParserUtil.parseGraphQuery(language, matcherQuery, null); } catch (OpenRDFException e) { throw new SailConfigException("Problem occured parsing matcher query: " + matcherQuery, e); } }
public Query prepareQuery(QueryLanguage ql, String query, String base) throws RepositoryException, MalformedQueryException { if (SPARQL.equals(ql)) { String strippedQuery = QueryParserUtil.removeSPARQLQueryProlog(query).toUpperCase(); if (strippedQuery.startsWith("SELECT")) { return prepareTupleQuery(ql, query, base); } else if (strippedQuery.startsWith("ASK")) { return prepareBooleanQuery(ql, query, base); } else { return prepareGraphQuery(ql, query, base); } } throw new UnsupportedOperationException("Unsupported query language " + ql); }
@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()); }
/** * Returns a <tt>SelectQuery</tt> for the specified SPARQL SELECT query string. * * @param string * the query string, in SPARQL and without relative URIs * @return the corresponding <tt>SelectQuery</tt> * @throws ParseException * in case the string does not denote a valid SPARQL SELECT query */ public static SelectQuery from(final String string) throws ParseException { Preconditions.checkNotNull(string); SelectQuery query = CACHE.getIfPresent(string); if (query == null) { final ParsedTupleQuery parsedQuery; try { parsedQuery = QueryParserUtil.parseTupleQuery(QueryLanguage.SPARQL, string, null); } catch (final IllegalArgumentException ex) { throw new ParseException(string, "SPARQL query not in SELECT form", ex); } catch (final MalformedQueryException ex) { throw new ParseException(string, "Invalid SPARQL query: " + ex.getMessage(), ex); } query = new SelectQuery(string, parsedQuery.getTupleExpr(), parsedQuery.getDataset()); CACHE.put(string, query); } return query; }
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); } }
private static synchronized CloseableIteration<? extends BindingSet, QueryEvaluationException> evaluateQuery(final String queryStr, final SailConnection sc) throws LocalFailure { ParsedGraphQuery query; try { query = QueryParserUtil.parseGraphQuery(QueryLanguage.SPARQL, queryStr, BASE_URI); } catch (MalformedQueryException e) { throw new LocalFailure(e); } MapBindingSet bindings = new MapBindingSet(); boolean includeInferred = false; try { return sc.evaluate(query.getTupleExpr(), query.getDataset(), bindings, includeInferred); } catch (SailException e) { throw new LocalFailure(e); } } }
@Override public Query prepareQuery(QueryLanguage ql, String queryString, String baseURI) throws RepositoryException, MalformedQueryException { if (ql != QueryLanguage.SPARQL) throw new MalformedQueryException("SPARQL query expected! "); ParsedQuery q = QueryParserUtil.parseQuery(QueryLanguage.SPARQL, queryString, baseURI); if (q instanceof ParsedTupleQuery) return prepareTupleQuery(ql,queryString, baseURI); else if (q instanceof ParsedBooleanQuery) return prepareBooleanQuery(ql, queryString, baseURI); else if (q instanceof ParsedGraphQuery) return prepareGraphQuery(ql, queryString, baseURI); else throw new MalformedQueryException("Unrecognized query type. " + queryString); }