Refine search
@Override public void initialize() throws RepositoryException { if (!open) throw new RepositoryException("Can not re-initialize"); }
private void closeAll(Iterable<RepositoryConnection> connections) { for (RepositoryConnection con : connections) { try { con.close(); } catch (RepositoryException e) { logger.error(e.getMessage(), e); } } } }
@Override public void handleStatement(Statement statement) { try { this.connection.add(statement); } catch (RepositoryException e) { e.printStackTrace(); } } }
public RepositoryConnection getConn(){ if(conn==null && repository == null) return null; try { if(conn==null || !conn.isOpen()){ conn=repository.getConnection(); return conn; } } catch (RepositoryException e) { log.error(e.toString()); for(StackTraceElement s: e.getStackTrace()) log.error(s.toString()); return null; } return conn; } }
public Response putContent(String uri, String mimetype, HttpServletRequest request) throws HttpErrorException { try { final RepositoryConnection conn = sesameService.getConnection(); try { conn.begin(); URI resource = conn.getValueFactory().createURI(uri); conn.commit(); return putContent(resource, mimetype, request); } finally { conn.close(); } } catch (RepositoryException e) { return Response.serverError().entity(e.getMessage()).build(); } }
@Test public void testGetStatementsMalformedLanguageLiteral() throws Exception { Literal invalidLanguageLiteral = vf.createLiteral("the number four", "en_us"); try { URI pred = vf.createURI(URN_PRED); testCon.add(bob, pred, invalidLanguageLiteral); RepositoryResult<Statement> statements = testCon.getStatements(bob, pred, null, true); assertNotNull(statements); assertTrue(statements.hasNext()); Statement st = statements.next(); assertTrue(st.getObject() instanceof Literal); assertTrue(st.getObject().equals(invalidLanguageLiteral)); } catch (RepositoryException e) { e.printStackTrace(); // shouldn't happen fail(e.getMessage()); } }
@Test public void testGetStatementsMalformedTypedLiteral() throws Exception { Literal invalidIntegerLiteral = vf.createLiteral("the number four", XMLSchema.INTEGER); try { URI pred = vf.createURI(URN_PRED); testCon.add(bob, pred, invalidIntegerLiteral); RepositoryResult<Statement> statements = testCon.getStatements(bob, pred, null, true); assertNotNull(statements); assertTrue(statements.hasNext()); Statement st = statements.next(); assertTrue(st.getObject() instanceof Literal); assertTrue(st.getObject().equals(invalidIntegerLiteral)); } catch (RepositoryException e) { // shouldn't happen fail(e.getMessage()); } }
@Override protected void finalize() throws Throwable { if (disk == this) { try { if (connection != null) { connection.commit(); connection.close(); } repository.shutDown(); } catch (RepositoryException e) { logger.error(e.toString(), e); } finally { FileUtil.deltree(repository.getDataDir()); repository = null; connection = null; disk = null; } } super.finalize(); } };
@Override public void clear(String contextName) { RepositoryConnection cnx = null; try { cnx = repo.getConnection(); cnx.clear(context(cnx, contextName)); } catch (RepositoryException x) { LOG.error("clearing context {} : {}", contextName, x.getMessage()); } finally { if (cnx != null) { try { cnx.close(); } catch (RepositoryException x) { LOG.error(x.getMessage()); } } } }
@Override public OWLAxiom next() throws RepositoryException { Statement stmt = stmts.next(); org.openrdf.model.URI axiomResource = (org.openrdf.model.URI) stmt.getSubject(); RepositoryConnection connection = repository.getConnection(); try { return anonymousHandler.removeSurrogates(parseAxiom(connection, axiomResource)); } catch (RepositoryException re) { throw re; } catch (Exception e) { throw new RepositoryException(e); } finally { connection.close(); } }
public void removeProjectFor( String groupId, String artifactId, String version, String artifactType ) throws ProjectDaoException { ValueFactory valueFactory = rdfRepository.getValueFactory(); URI id = valueFactory.createURI( groupId + ":" + artifactId + ":" + version + ":" + artifactType ); try { repositoryConnection.remove( repositoryConnection.getStatements( id, null, null, true ) ); } catch ( RepositoryException e ) { throw new ProjectDaoException( e.getMessage(), e ); } }
private static int statementsCount(RepositoryConnection conn, Resource ctx) { int counter = 0; try { RepositoryResult<Statement> statements = conn.getStatements(null, null, null, true, ctx); while (statements.hasNext()) { counter++; statements.next(); } } catch (RepositoryException e) { LOG.error(e.getMessage()); } return counter; }
/** * Check for the existence of a {@link Statement} with the provided constraints. <code>null</code> is a wildcard. * <br>This is a convenience method and does not really fit whith <em>Resource</em>Utils. * * @param conn the {@link org.apache.marmotta.commons.sesame.repository.ResourceConnection} to check on * @param subj the subject of the {@link org.openrdf.model.Statement} or <code>null</code> for a wildcard. * @param pred the predicate of the {@link org.openrdf.model.Statement} or <code>null</code> for a wildcard. * @param object the object of the {@link org.openrdf.model.Statement} or <code>null</code> for a wildcard. * @return true if a {@link Statement} with the provided constraints exists. */ public static boolean existsStatement(RepositoryConnection conn, Resource subj, URI pred, Value object, Resource ... context) { try { return conn.hasStatement(subj,pred,object,true,context); } catch (RepositoryException e) { log.error(e.getMessage()); return false; } }
public TripleStoreBlazegraph() { final Properties props = new Properties(); props.put(Options.BUFFER_MODE, "MemStore"); props.put(AbstractTripleStore.Options.QUADS_MODE, "true"); props.put(BigdataSail.Options.TRUTH_MAINTENANCE, "false"); // Quiet System.getProperties().setProperty("com.bigdata.Banner.quiet", "true"); System.getProperties().setProperty("com.bigdata.util.config.LogUtil.quiet", "true"); BigdataSail sail = new BigdataSail(props); // instantiate a sail repo = new BigdataSailRepository(sail); // create a Sesame repository try { repo.initialize(); } catch (RepositoryException x) { LOG.error("Repository could not be created {}", x.getMessage()); } }
private ModelAndView getUpdateNamespaceResult(HttpServletRequest request, String prefix) throws IOException, ClientHTTPException, ServerHTTPException { String namespace = IOUtil.readString(request.getReader()); namespace = namespace.trim(); if (namespace.length() == 0) { throw new ClientHTTPException(SC_BAD_REQUEST, "No namespace name found in request body"); } // FIXME: perform some sanity checks on the namespace string try { RepositoryConnection repositoryCon = RepositoryInterceptor.getRepositoryConnection(request); synchronized (repositoryCon) { repositoryCon.setNamespace(prefix, namespace); } } catch (RepositoryException e) { throw new ServerHTTPException("Repository error: " + e.getMessage(), e); } return new ModelAndView(EmptySuccessView.getInstance()); }
private ModelAndView getExportNamespaceResult(HttpServletRequest request, String prefix) throws ServerHTTPException, ClientHTTPException { try { String namespace = null; RepositoryConnection repositoryCon = RepositoryInterceptor.getRepositoryConnection(request); synchronized (repositoryCon) { namespace = repositoryCon.getNamespace(prefix); } if (namespace == null) { throw new ClientHTTPException(SC_NOT_FOUND, "Undefined prefix: " + prefix); } Map<String, Object> model = new HashMap<String, Object>(); model.put(SimpleResponseView.CONTENT_KEY, namespace); return new ModelAndView(SimpleResponseView.getInstance(), model); } catch (RepositoryException e) { throw new ServerHTTPException("Repository error: " + e.getMessage(), e); } }
private ModelAndView getRemoveNamespaceResult(HttpServletRequest request, String prefix) throws ServerHTTPException { try { RepositoryConnection repositoryCon = RepositoryInterceptor.getRepositoryConnection(request); synchronized (repositoryCon) { repositoryCon.removeNamespace(prefix); } } catch (RepositoryException e) { throw new ServerHTTPException("Repository error: " + e.getMessage(), e); } return new ModelAndView(EmptySuccessView.getInstance()); } }
public void execute(RepositoryConnection con) throws RepositoryException { try { Update preparedUpdate = con.prepareUpdate(QueryLanguage.SPARQL, getUpdateString(), getBaseURI()); preparedUpdate.setIncludeInferred(isIncludeInferred()); preparedUpdate.setDataset(getDataset()); if (getBindings() != null) { for (Binding binding : getBindings()) { preparedUpdate.setBinding(binding.getName(), binding.getValue()); } } preparedUpdate.execute(); } catch (MalformedQueryException e) { throw new RepositoryException(e); } catch (UpdateExecutionException e) { throw new RepositoryException(e); } }
private ModelAndView getClearNamespacesResult(HttpServletRequest request, HttpServletResponse response) throws ServerHTTPException { RepositoryConnection repositoryCon = RepositoryInterceptor.getRepositoryConnection(request); synchronized (repositoryCon) { try { repositoryCon.clearNamespaces(); } catch (RepositoryException e) { throw new ServerHTTPException("Repository error: " + e.getMessage(), e); } } return new ModelAndView(EmptySuccessView.getInstance()); } }
public boolean isActive() { try { return connection.getConnection().isActive(); } catch (UnknownTransactionStateException e) { logger.error(e.getMessage(), e); throw new RepositoryException(e.getMessage(), e); } catch (org.openrdf.repository.RepositoryException e) { logger.error(e.getMessage(), e); throw new RepositoryException(e.getMessage(), e); } }