@Override protected void meetNode(QueryModelNode node) { MalformedQueryException initCause; String msg = "Unknown statement: " + predicate + " " + object; initCause = new MalformedQueryException(msg); throw new UndeclaredThrowableException(initCause); }
public void getRepositoryList(TupleQueryResultHandler handler) throws IOException, TupleQueryResultHandlerException, RepositoryException, UnauthorizedException, QueryInterruptedException { checkServerURL(); HttpGet method = new HttpGet(Protocol.getRepositoriesLocation(serverURL)); try { getTupleQueryResult(method, handler); } catch (MalformedQueryException e) { // This shouldn't happen as no queries are involved logger.warn("Server reported unexpected malfored query error", e); throw new RepositoryException(e.getMessage(), e); } }
@Override protected void runTest() throws Exception { InputStream stream = new URL(queryFileURL).openStream(); String query = IOUtil.readString(new InputStreamReader(stream, "UTF-8")); stream.close(); try { parseQuery(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()); } } }
public SPARQLQuery(Reader in, String base) throws IOException, MalformedQueryException { try { StringWriter sw = new StringWriter(); int read; char[] cbuf = new char[1024]; while ((read = in.read(cbuf)) >= 0) { sw.write(cbuf, 0, read); } sparql = sw.toString(); this.base = base; try { query = new SPARQLParser().parseQuery(sparql, base); } catch (MalformedQueryException e) { try { query = new SPARQLParser().parseUpdate(sparql, base); } catch (MalformedQueryException u) { throw e; } } } catch (MalformedQueryException e) { throw new MalformedQueryException(base + " " + e.getMessage(), e); } finally { in.close(); } }
@Override public double analyze(String contributionIdA, String contributionIdB){ try { RepositoryConnection conn = getConn(); double result = checkIfSimilar(conn, contributionIdA,contributionIdB); conn.close(); return result; } catch (RepositoryException e) { log.error(e.toString()); // log.error(Arrays.toString(e.getStackTrace())); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (MalformedQueryException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (QueryEvaluationException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (Exception e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } return 0; }
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) { ModelAndView result = new ModelAndView(); result.setViewName(view); Map<String, Object> model = new HashMap<String, Object>(); try { List<Resource> classes = getClasses(request); Collections.sort(classes, ToStringComparator.getInstance()); model.put("classes", classes); } catch (RepositoryException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (QueryEvaluationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (MalformedQueryException e) { // TODO Auto-generated catch block e.printStackTrace(); } result.addAllObjects(model); return result; }
throw new MalformedQueryException("empty query"); } catch (MalformedQueryException ex) { String str = ex.getMessage(); close(conn, ex); return Response.status(Response.Status.BAD_REQUEST).entity(
} catch (final MalformedQueryException e) e.printStackTrace(); } catch (final QueryEvaluationException e)
log.error(s.toString()); } catch (MalformedQueryException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (QueryEvaluationException e) {
public SesameGraphQuery(String queryString, String baseURI, QuestDBConnection conn) throws MalformedQueryException { super(queryString, conn); if (queryString.toLowerCase().contains("construct") || queryString.toLowerCase().contains("describe")) { this.baseURI = baseURI; } else throw new MalformedQueryException("Graph query expected!"); }
public SparqlQuery(Reader in, String base) throws IOException, MalformedQueryException { try { StringWriter sw = new StringWriter(); int read; char[] cbuf = new char[1024]; while ((read = in.read(cbuf)) >= 0) { sw.write(cbuf, 0, read); } sparql = sw.toString(); this.base = base; try { query = new SPARQLParser().parseQuery(sparql, base); } catch (MalformedQueryException e) { try { query = new SPARQLParser().parseUpdate(sparql, base); } catch (MalformedQueryException u) { throw e; } } } catch (MalformedQueryException e) { logger.warn(base + " " + e.getMessage(), e); } }
@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()); } } }
} catch (final MalformedQueryException e) e.printStackTrace(); } catch (final QueryEvaluationException e)
log.error(s.toString()); } catch (MalformedQueryException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (QueryEvaluationException e) {
@Override public TupleQuery prepareTupleQuery(QueryLanguage ql, String queryString, String baseURI) throws RepositoryException, MalformedQueryException { //Prepares a query that produces sets of value tuples. if (ql != QueryLanguage.SPARQL) throw new MalformedQueryException("SPARQL query expected!"); return new SesameTupleQuery(queryString, baseURI, questConn); }
public void getContextIDs(TupleQueryResultHandler handler) throws IOException, TupleQueryResultHandlerException, RepositoryException, UnauthorizedException, QueryInterruptedException { checkRepositoryURL(); HttpGet method = new HttpGet(Protocol.getContextsLocation(getQueryURL())); try { getTupleQueryResult(method, handler); } catch (MalformedQueryException e) { logger.warn("Server reported unexpected malfored query error", e); throw new RepositoryException(e.getMessage(), e); } }
e.printStackTrace(); fail("Positive test case failed: " + e.getMessage());
/** * Clears the Anno4j underlying triplestore. * This is required in order to prevent a drop in throughput while parsing. * * @throws RepositoryException Thrown if no connection to the object repository could be made. * @throws UpdateExecutionException Thrown if an error occurred while executing the clearing query. */ private void clear() throws RepositoryException, UpdateExecutionException { String deleteUpdate = "DELETE {?s ?p ?o}\n" + "WHERE {?s ?p ?o}"; ObjectConnection connection = anno4j.getObjectRepository().getConnection(); Update update; try { update = connection.prepareUpdate(deleteUpdate); } catch (MalformedQueryException e) { e.printStackTrace(); return; } update.execute(); }
log.error(s.toString()); } catch (MalformedQueryException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); } catch (QueryEvaluationException e) {
@Override public SailQuery prepareQuery(final QueryLanguage ql, final String qs, final String baseURI) throws MalformedQueryException { if (ql == QueryLanguage.SPARQL) { return (SailQuery) prepareNativeSPARQLQuery(ql, qs, baseURI); } throw new MalformedQueryException("Unsupported language: " + ql); }