Uses of Class
org.eclipse.rdf4j.repository.RepositoryException

Packages that use RepositoryException

Package	Description
org.eclipse.rdf4j.repository	The Repository API: the main API for accessing rdf databases and SPARQL endpoints.
org.eclipse.rdf4j.repository.base	Abstract base classes and wrappers for the main Repository API interfaces.
org.eclipse.rdf4j.repository.config	Repository configuration interfaces.
org.eclipse.rdf4j.repository.util	Helper classes for working with Repositories.

Uses of RepositoryException in org.eclipse.rdf4j.repository

Subclasses of RepositoryException in org.eclipse.rdf4j.repository

Modifier and Type	Class	Description
class	RepositoryLockedException	Indicates that a Repository cannot be initialised because the configured persisted location is locked.
class	RepositoryReadOnlyException	Indicates that the current write operation did not succeed because the SAIL cannot be written to, it can only be read from.
class	UnknownTransactionStateException	A specific subtype of RepositoryException that indicates the connection's transaction state can not be determined.

Methods in org.eclipse.rdf4j.repository that throw RepositoryException

Modifier and Type	Method	Description
void	RepositoryConnection.add(File file, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from the specified file to a specific contexts in the repository.
default void	RepositoryConnection.add(File file, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from the specified file to a specific contexts in the repository.
default void	RepositoryConnection.add(File file, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from the specified file to a specific contexts in the repository.
void	RepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(InputStream in, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
void	RepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(Reader reader, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
void	RepositoryConnection.add(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Adds the supplied statements to this repository, optionally to one or more named contexts.
void	RepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(URL url, org.eclipse.rdf4j.model.Resource... contexts)	Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(URL url, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)	Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
void	RepositoryConnection.add(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Adds the supplied statements to this repository, optionally to one or more named contexts.
void	RepositoryConnection.add(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)	Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
void	RepositoryConnection.add(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)	Adds the supplied statement to this repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(RepositoryResult<org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Adds the supplied statements to this repository, optionally to one or more named contexts.
<C extends Collection<T>> C	RepositoryResult.addTo(C collection)	Deprecated. Use Iterations.addAll(CloseableIteration, Collection) instead.
List<T>	RepositoryResult.asList()	Deprecated. Use Iterations.asList(CloseableIteration) instead.
void	RepositoryConnection.begin()	Begins a new transaction, requiring RepositoryConnection.commit() or RepositoryConnection.rollback() to be called to end the transaction.
void	RepositoryConnection.begin(IsolationLevel level)	Begins a new transaction with the supplied IsolationLevel, requiring RepositoryConnection.commit() or RepositoryConnection.rollback() to be called to end the transaction.
void	RepositoryConnection.clear(org.eclipse.rdf4j.model.Resource... contexts)	Removes all statements from a specific contexts in the repository.
void	RepositoryConnection.clearNamespaces()	Removes all namespace declarations from the repository.
default void	RepositoryConnection.close()	Closes the connection, freeing resources.
void	RepositoryConnection.commit()	Commits the active transaction.
void	RepositoryResult.enableDuplicateFilter()	Switches on duplicate filtering while iterating over objects.
void	RepositoryConnection.export(RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts)	Exports all explicit statements in the specified contexts to the supplied RDFHandler.
void	RepositoryConnection.exportStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts)	Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.
RepositoryConnection	Repository.getConnection()	Opens a connection to this repository that can be used for querying and updating the contents of the repository.
RepositoryResult<org.eclipse.rdf4j.model.Resource>	RepositoryConnection.getContextIDs()	Gets all resources that are used as content identifiers.
RepositoryConnection	DelegatingRepositoryConnection.getDelegate()
String	RepositoryConnection.getNamespace(String prefix)	Gets the namespace that is associated with the specified prefix, if any.
RepositoryResult<org.eclipse.rdf4j.model.Namespace>	RepositoryConnection.getNamespaces()	Gets all declared namespaces as a RepositoryResult of Namespace objects.
Repository	RepositoryResolver.getRepository(String memberID)
RepositoryResult<org.eclipse.rdf4j.model.Statement>	RepositoryConnection.getStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)	Gets all statements with a specific subject, predicate and/or object from the repository.
default RepositoryResult<org.eclipse.rdf4j.model.Statement>	RepositoryConnection.getStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, org.eclipse.rdf4j.model.Resource... contexts)	Gets all statements with a specific subject, predicate and/or object from the repository.
protected void	RepositoryResult.handleClose()
boolean	RepositoryResult.hasNext()
boolean	RepositoryConnection.hasStatement(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)	Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
boolean	RepositoryConnection.hasStatement(org.eclipse.rdf4j.model.Statement st, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)	Checks whether the repository contains the specified statement, optionally in the specified contexts.
void	Repository.init()	Initializes this repository.
boolean	RepositoryConnection.isActive()	Indicates if a transaction is currently active on the connection.
boolean	RepositoryConnection.isAutoCommit()	Deprecated. Use RepositoryConnection.isActive() instead.
boolean	RepositoryConnection.isEmpty()	Returns true if this repository does not contain any (explicit) statements.
boolean	RepositoryConnection.isOpen()	Checks whether this connection is open.
boolean	Repository.isWritable()	Checks whether this repository is writable, i.e.
T	RepositoryResult.next()
default void	RepositoryConnection.prepare()	Checks for an error state in the active transaction that would force the transaction to be rolled back.
default BooleanQuery	RepositoryConnection.prepareBooleanQuery(String query)	Prepares SPARQL queries that return true or false, that is, SPARQL ASK queries.
BooleanQuery	RepositoryConnection.prepareBooleanQuery(QueryLanguage ql, String query)	Prepares queries that return true or false.
BooleanQuery	RepositoryConnection.prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)	Prepares queries that return true or false.
default GraphQuery	RepositoryConnection.prepareGraphQuery(String query)	Prepares SPARQL queries that produce RDF graphs, that is, SPARQL CONSTRUCT or DESCRIBE queries.
GraphQuery	RepositoryConnection.prepareGraphQuery(QueryLanguage ql, String query)	Prepares queries that produce RDF graphs.
GraphQuery	RepositoryConnection.prepareGraphQuery(QueryLanguage ql, String query, String baseURI)	Prepares queries that produce RDF graphs.
default Query	RepositoryConnection.prepareQuery(String query)	Prepares a SPARQL query for evaluation on this repository (optional operation).
Query	RepositoryConnection.prepareQuery(QueryLanguage ql, String query)	Prepares a query for evaluation on this repository (optional operation).
Query	RepositoryConnection.prepareQuery(QueryLanguage ql, String query, String baseURI)	Prepares a query for evaluation on this repository (optional operation).
default TupleQuery	RepositoryConnection.prepareTupleQuery(String query)	Prepares a SPARQL query that produces sets of value tuples, that is a SPARQL SELECT query.
TupleQuery	RepositoryConnection.prepareTupleQuery(QueryLanguage ql, String query)	Prepares a query that produces sets of value tuples.
TupleQuery	RepositoryConnection.prepareTupleQuery(QueryLanguage ql, String query, String baseURI)	Prepares a query that produces sets of value tuples.
default Update	RepositoryConnection.prepareUpdate(String update)	Prepares a SPARQL Update operation.
Update	RepositoryConnection.prepareUpdate(QueryLanguage ql, String update)	Prepares an Update operation.
Update	RepositoryConnection.prepareUpdate(QueryLanguage ql, String update, String baseURI)	Prepares an Update operation.
void	RepositoryConnection.remove(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Removes the supplied statements from the specified contexts in this repository.
void	RepositoryConnection.remove(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
void	RepositoryConnection.remove(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)	Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
void	RepositoryConnection.remove(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)	Removes the supplied statement from the specified contexts in the repository.
default void	RepositoryConnection.remove(RepositoryResult<org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)	Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
void	RepositoryResult.remove()
void	RepositoryConnection.removeNamespace(String prefix)	Removes a namespace declaration by removing the association between a prefix and a namespace name.
void	RepositoryConnection.rollback()	Rolls back all updates in the active transaction.
void	RepositoryConnection.setAutoCommit(boolean autoCommit)	Deprecated. Use RepositoryConnection.begin() instead.
void	RepositoryConnection.setNamespace(String prefix, String name)	Sets the prefix for a namespace.
void	Repository.shutDown()	Shuts the repository down, releasing any resources that it keeps hold of.
long	RepositoryConnection.size(org.eclipse.rdf4j.model.Resource... contexts)	Returns the number of (explicit) statements that are in the specified contexts in this repository.

Uses of RepositoryException in org.eclipse.rdf4j.repository.base

Methods in org.eclipse.rdf4j.repository.base that throw RepositoryException

Modifier and Type	Method	Description
void	AbstractRepositoryConnection.add(File file, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.add(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(File file, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(InputStream in, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(Reader reader, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(URL url, String baseURI, RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statementIter, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.add(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
protected abstract void	AbstractRepositoryConnection.addWithoutCommit(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
protected void	AbstractRepositoryConnection.addWithoutCommit(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
protected void	RepositoryConnectionWrapper.addWithoutCommit(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.begin(IsolationLevel level)
void	RepositoryConnectionWrapper.begin()
void	RepositoryConnectionWrapper.begin(IsolationLevel level)
void	AbstractRepositoryConnection.clear(org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.clear(org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.clearNamespaces()
void	AbstractRepositoryConnection.close()
void	RepositoryConnectionWrapper.close()
void	RepositoryConnectionWrapper.commit()
protected void	AbstractRepositoryConnection.conditionalCommit(boolean condition)	Invokes RepositoryConnection.commit() if supplied boolean condition is true.
protected void	AbstractRepositoryConnection.conditionalRollback(boolean condition)	Invokes RepositoryConnection.rollback() if supplied boolean condition is true.
void	AbstractRepositoryConnection.export(RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.exportStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts)
protected void	RepositoryConnectionWrapper.exportStatements(RepositoryResult<org.eclipse.rdf4j.model.Statement> stIter, RDFHandler handler)	Exports all statements contained in the supplied statement iterator and all relevant namespace information to the supplied RDFHandler.
RepositoryConnection	RepositoryWrapper.getConnection()
RepositoryResult<org.eclipse.rdf4j.model.Resource>	RepositoryConnectionWrapper.getContextIDs()
abstract String	AbstractRepositoryConnection.getNamespace(String prefix)
String	RepositoryConnectionWrapper.getNamespace(String prefix)
RepositoryResult<org.eclipse.rdf4j.model.Namespace>	RepositoryConnectionWrapper.getNamespaces()
RepositoryResult<org.eclipse.rdf4j.model.Statement>	RepositoryConnectionWrapper.getStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)
boolean	AbstractRepositoryConnection.hasStatement(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)
boolean	AbstractRepositoryConnection.hasStatement(org.eclipse.rdf4j.model.Statement st, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)
boolean	RepositoryConnectionWrapper.hasStatement(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)
boolean	RepositoryConnectionWrapper.hasStatement(org.eclipse.rdf4j.model.Statement st, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepository.init()
void	RepositoryWrapper.init()
protected abstract void	AbstractRepository.initializeInternal()
boolean	RepositoryConnectionWrapper.isActive()
boolean	AbstractRepositoryConnection.isAutoCommit()	Deprecated. Use RepositoryConnection.isActive() instead.
boolean	RepositoryConnectionWrapper.isAutoCommit()	Deprecated. Use RepositoryConnectionWrapper.isActive() instead.
protected boolean	RepositoryConnectionWrapper.isDelegatingAdd()	If false then the following add methods will call RepositoryConnectionWrapper.addWithoutCommit(Resource, IRI, Value, Resource[]).
protected boolean	RepositoryConnectionWrapper.isDelegatingRead()	If false then the following has/export/isEmpty methods will call RepositoryConnectionWrapper.getStatements(Resource, IRI, Value, boolean, Resource[]).
protected boolean	RepositoryConnectionWrapper.isDelegatingRemove()	If false then the following remove methods will call RepositoryConnectionWrapper.removeWithoutCommit(Resource, IRI, Value, Resource[]).
boolean	AbstractRepositoryConnection.isEmpty()
boolean	RepositoryConnectionWrapper.isEmpty()
boolean	AbstractRepositoryConnection.isOpen()
boolean	RepositoryConnectionWrapper.isOpen()
boolean	RepositoryWrapper.isWritable()
void	RepositoryConnectionWrapper.prepare()
BooleanQuery	AbstractRepositoryConnection.prepareBooleanQuery(QueryLanguage ql, String query)
BooleanQuery	RepositoryConnectionWrapper.prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)
GraphQuery	AbstractRepositoryConnection.prepareGraphQuery(QueryLanguage ql, String query)
GraphQuery	RepositoryConnectionWrapper.prepareGraphQuery(QueryLanguage ql, String query, String baseURI)
Query	AbstractRepositoryConnection.prepareQuery(QueryLanguage ql, String query)
Query	RepositoryConnectionWrapper.prepareQuery(QueryLanguage ql, String query, String baseURI)
TupleQuery	AbstractRepositoryConnection.prepareTupleQuery(QueryLanguage ql, String query)
TupleQuery	RepositoryConnectionWrapper.prepareTupleQuery(QueryLanguage ql, String query, String baseURI)
Update	AbstractRepositoryConnection.prepareUpdate(QueryLanguage ql, String update)
Update	RepositoryConnectionWrapper.prepareUpdate(QueryLanguage ql, String update, String baseURI)
void	AbstractRepositoryConnection.remove(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.remove(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.remove(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	AbstractRepositoryConnection.remove(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.remove(Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.remove(org.eclipse.rdf4j.common.iteration.CloseableIteration<? extends org.eclipse.rdf4j.model.Statement> statementIter, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.remove(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.remove(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.removeNamespace(String prefix)
protected abstract void	AbstractRepositoryConnection.removeWithoutCommit(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
protected void	AbstractRepositoryConnection.removeWithoutCommit(org.eclipse.rdf4j.model.Statement st, org.eclipse.rdf4j.model.Resource... contexts)
protected void	RepositoryConnectionWrapper.removeWithoutCommit(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)
void	RepositoryConnectionWrapper.rollback()
void	AbstractRepositoryConnection.setAutoCommit(boolean autoCommit)	Deprecated. Use RepositoryConnection.begin() instead.
void	RepositoryConnectionWrapper.setAutoCommit(boolean autoCommit)	Deprecated. use RepositoryConnectionWrapper.begin() instead.
abstract void	AbstractRepositoryConnection.setNamespace(String prefix, String name)
void	RepositoryConnectionWrapper.setNamespace(String prefix, String name)
void	AbstractRepository.shutDown()
void	RepositoryWrapper.shutDown()
protected abstract void	AbstractRepository.shutDownInternal()
long	RepositoryConnectionWrapper.size(org.eclipse.rdf4j.model.Resource... contexts)
protected boolean	AbstractRepositoryConnection.startLocalTransaction()	Starts a new transaction if one is not already active.

Uses of RepositoryException in org.eclipse.rdf4j.repository.config

Methods in org.eclipse.rdf4j.repository.config that throw RepositoryException

Modifier and Type	Method	Description
static org.eclipse.rdf4j.model.Resource	RepositoryConfigUtil.getContext(RepositoryConnection con, String repositoryID)	Deprecated.
static RepositoryConfig	RepositoryConfigUtil.getRepositoryConfig(Repository repository, String repositoryID)	Deprecated.
static Set<String>	RepositoryConfigUtil.getRepositoryIDs(org.eclipse.rdf4j.model.Model model)
static Set<String>	RepositoryConfigUtil.getRepositoryIDs(Repository repository)	Deprecated.
static boolean	RepositoryConfigUtil.hasRepositoryConfig(Repository repository, String repositoryID)	Deprecated.
static boolean	RepositoryConfigUtil.removeRepositoryConfigs(Repository repository, String... repositoryIDs)	Deprecated.
static void	RepositoryConfigUtil.updateRepositoryConfigs(RepositoryConnection con, RepositoryConfig... configs)	Deprecated.
static void	RepositoryConfigUtil.updateRepositoryConfigs(Repository repository, RepositoryConfig... configs)	Deprecated.

Uses of RepositoryException in org.eclipse.rdf4j.repository.util

Methods in org.eclipse.rdf4j.repository.util that return types with arguments of type RepositoryException

Modifier and Type	Method	Description
static Supplier<RepositoryException>	Repositories.repositoryException(String message)	Creates a Supplier of RepositoryException objects that be passed to Optional.orElseThrow(Supplier) to generate exceptions as necessary.

Method parameters in org.eclipse.rdf4j.repository.util with type arguments of type RepositoryException

Modifier and Type	Method	Description
static <T> T	Repositories.get(Repository repository, Function<RepositoryConnection,T> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository within a transaction, sends the connection to the given Function, before either rolling back the transaction if it failed, or committing the transaction if it was successful.
static <T> T	Repositories.getNoTransaction(Repository repository, Function<RepositoryConnection,T> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository without opening a transaction, sends the connection to the given Function.

Methods in org.eclipse.rdf4j.repository.util that throw RepositoryException

Modifier and Type	Method	Description
static void	Repositories.consume(Repository repository, Consumer<RepositoryConnection> processFunction)	Opens a RepositoryConnection to the given Repository within a transaction, sends the connection to the given Consumer, before either rolling back the transaction if it failed, or committing the transaction if it was successful.
static void	Repositories.consume(Repository repository, Consumer<RepositoryConnection> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository within a transaction, sends the connection to the given Consumer, before either rolling back the transaction if it failed, or committing the transaction if it was successful.
static void	Repositories.consumeNoTransaction(Repository repository, Consumer<RepositoryConnection> processFunction)	Opens a RepositoryConnection to the given Repository without opening a transaction, sends the connection to the given Consumer.
static void	Repositories.consumeNoTransaction(Repository repository, Consumer<RepositoryConnection> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository without opening a transaction, sends the connection to the given Consumer.
static void	Connections.consumeRDFCollection(RepositoryConnection conn, org.eclipse.rdf4j.model.Resource head, Consumer<org.eclipse.rdf4j.model.Statement> collectionConsumer, org.eclipse.rdf4j.model.Resource... contexts)	Retrieve all Statements that together form the RDF Collection starting with the supplied start resource and send them to the supplied Consumer.
static Collection<? extends org.eclipse.rdf4j.model.Statement>	RepositoryUtil.difference(Repository rep1, Repository rep2)	Compares two models defined by the default context of two repositories and returns the difference between the first and the second model (that is, all statements that are present in rep1 but not in rep2).
static boolean	RepositoryUtil.equals(Repository rep1, Repository rep2)	Compares the models in the default contexts of the two supplied repositories and returns true if they are equal.
static <T> T	Repositories.get(Repository repository, Function<RepositoryConnection,T> processFunction)	Opens a RepositoryConnection to the given Repository within a transaction, sends the connection to the given Function, before either rolling back the transaction if it failed, or committing the transaction if it was successful.
static <T> T	Repositories.get(Repository repository, Function<RepositoryConnection,T> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository within a transaction, sends the connection to the given Function, before either rolling back the transaction if it failed, or committing the transaction if it was successful.
static <T> T	Repositories.getNoTransaction(Repository repository, Function<RepositoryConnection,T> processFunction)	Opens a RepositoryConnection to the given Repository without opening a transaction, sends the connection to the given Function.
static <T> T	Repositories.getNoTransaction(Repository repository, Function<RepositoryConnection,T> processFunction, Consumer<RepositoryException> exceptionHandler)	Opens a RepositoryConnection to the given Repository without opening a transaction, sends the connection to the given Function.
static <C extends Collection<org.eclipse.rdf4j.model.Statement>> C	Connections.getRDFCollection(RepositoryConnection conn, org.eclipse.rdf4j.model.Resource head, C statementCollection, org.eclipse.rdf4j.model.Resource... contexts)	Retrieve all Statements that together form the RDF Collection starting with the supplied starting resource.
static Optional<org.eclipse.rdf4j.model.Statement>	Connections.getStatement(RepositoryConnection conn, org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts)	Retrieve a single Statement matching with the supplied subject, predicate, object and context(s) from the given RepositoryConnection.
static <T> T	Repositories.graphQuery(Repository repository, String query, Function<GraphQueryResult,T> processFunction)	Performs a SPARQL Construct or Describe query on the given Repository within a transaction and passes the results to the given Function with the result from the function returned by the method.
static void	Repositories.graphQuery(Repository repository, String query, RDFHandler handler)	Performs a SPARQL Construct or Describe query on the given Repository within a transaction and passes the results to the given RDFHandler.
static <T> T	Repositories.graphQueryNoTransaction(Repository repository, String query, Function<GraphQueryResult,T> processFunction)	Performs a SPARQL Construct or Describe query on the given Repository without opening a transaction and passes the results to the given Function with the result from the function returned by the method.
static void	Repositories.graphQueryNoTransaction(Repository repository, String query, RDFHandler handler)	Performs a SPARQL Construct or Describe query on the given Repository without opening a transaction and passes the results to the given RDFHandler.
static boolean	RepositoryUtil.isSubset(Repository rep1, Repository rep2)	Compares the models of the default context of two repositories and returns true if rep1 is a subset of rep2.
static <T> T	Repositories.tupleQuery(Repository repository, String query, Function<TupleQueryResult,T> processFunction)	Performs a SPARQL Select query on the given Repository within a transaction and passes the results to the given Function with the result from the function returned by the method.
static void	Repositories.tupleQuery(Repository repository, String query, TupleQueryResultHandler handler)	Performs a SPARQL Select query on the given Repository within a transaction and passes the results to the given TupleQueryResultHandler.
static <T> T	Repositories.tupleQueryNoTransaction(Repository repository, String query, Function<TupleQueryResult,T> processFunction)	Performs a SPARQL Select query on the given Repository without opening a transaction and passes the results to the given Function with the result from the function returned by the method.
static void	Repositories.tupleQueryNoTransaction(Repository repository, String query, TupleQueryResultHandler handler)	Performs a SPARQL Select query on the given Repository without opening a transaction and passes the results to the given TupleQueryResultHandler.