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

Packages that use RepositoryException

Package	Description
org.eclipse.rdf4j.console	A command line console tool for querying and updating local or remote RDF4J repositories.
org.eclipse.rdf4j.console.command
org.eclipse.rdf4j.federated
org.eclipse.rdf4j.federated.algebra
org.eclipse.rdf4j.federated.endpoint
org.eclipse.rdf4j.federated.evaluation
org.eclipse.rdf4j.federated.repository
org.eclipse.rdf4j.federated.write
org.eclipse.rdf4j.http.client
org.eclipse.rdf4j.http.protocol
org.eclipse.rdf4j.http.protocol.transaction.operations
org.eclipse.rdf4j.http.server.repository
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.contextaware	A repository wrapper with convenience functions for handling contexts.
org.eclipse.rdf4j.repository.dataset	A repository wrapper which supports auto-loading of datasets specified in a query.
org.eclipse.rdf4j.repository.event	Interfaces for notification/interception of events happening on Repositories and RepositoryConnections
org.eclipse.rdf4j.repository.event.base	Wrapper/adapter base implementations.
org.eclipse.rdf4j.repository.http	A repository that serves as a proxy client for a remote repository on an RDF4J Server.
org.eclipse.rdf4j.repository.manager	Functionality for Repository lifecycle management and sharing.
org.eclipse.rdf4j.repository.manager.util
org.eclipse.rdf4j.repository.sail	Repository implementation for local RDF databases that implement the SAIL SPI.
org.eclipse.rdf4j.repository.sail.config
org.eclipse.rdf4j.repository.sparql	A Repository that serves as a SPARQL endpoint client.
org.eclipse.rdf4j.repository.sparql.federation
org.eclipse.rdf4j.repository.util	Helper classes for working with Repositories.
org.eclipse.rdf4j.spring.operationlog	Rdf4j-Spring OperationLog
org.eclipse.rdf4j.spring.pool	Rdf4j-Spring Pool
org.eclipse.rdf4j.spring.resultcache	Rdf4j-Spring ResultCache
org.eclipse.rdf4j.spring.tx	Rdf4J-Spring Tx
org.eclipse.rdf4j.testsuite.query.parser.sparql
org.eclipse.rdf4j.testsuite.repository
org.eclipse.rdf4j.testsuite.repository.optimistic
org.eclipse.rdf4j.testsuite.sparql	A SPARQL test suite for RDF4J repositories
org.eclipse.rdf4j.workbench.commands
org.eclipse.rdf4j.workbench.util
org.eclipse.testsuite.rdf4j.sail.lucene

Uses of RepositoryException in org.eclipse.rdf4j.console

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

Modifier and Type	Method	Description
static boolean	LockRemover.tryToRemoveLock(Repository repo, ConsoleIO consoleIO)	Try to remove lock from repository

Uses of RepositoryException in org.eclipse.rdf4j.console.command

Methods in org.eclipse.rdf4j.console.command that throw RepositoryException

Modifier and Type	Method	Description
protected void	TupleAndGraphQueryEvaluator.evaluateBooleanQuery(QueryLanguage queryLn, String queryString, QueryResultWriter writer)	Evaluate a boolean SPARQL query
protected void	TupleAndGraphQueryEvaluator.evaluateGraphQuery(QueryLanguage queryLn, String queryString, RDFWriter writer, Collection<Namespace> namespaces)	Evaluate SPARQL graph query
protected void	TupleAndGraphQueryEvaluator.evaluateTupleQuery(QueryLanguage queryLn, String queryString, QueryResultWriter writer)	Evaluate SPARQL tuple query and send the output to a writer.
protected void	TupleAndGraphQueryEvaluator.executeUpdate(QueryLanguage queryLn, String queryString)	Execute a SPARQL update

Uses of RepositoryException in org.eclipse.rdf4j.federated

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

Modifier and Type	Method	Description
void	FederationManager.removeAll()	Remove all endpoints from the federation, e.g.
void	FederationManager.removeEndpoint(Endpoint e, boolean... updateStrategy)	Remove the specified endpoint from the federation.

Uses of RepositoryException in org.eclipse.rdf4j.federated.algebra

Methods in org.eclipse.rdf4j.federated.algebra that throw RepositoryException

Modifier and Type	Method	Description
protected CloseableIteration<BindingSet>	StatementSourcePattern.handleStatementSourcePatternCheck(BindingSet bindings)

Uses of RepositoryException in org.eclipse.rdf4j.federated.endpoint

Methods in org.eclipse.rdf4j.federated.endpoint that throw RepositoryException

Modifier and Type	Method	Description
void	EndpointBase.ManagedRepositoryConnection.close()
void	EndpointBase.ManagedRepositoryConnection.closeManagedConnection()
void	Endpoint.init(FederationContext federationContext)	Initialize this Endpoint
void	EndpointBase.init(FederationContext federationContext)
void	ManagedRepositoryEndpoint.init(FederationContext federationContext)
void	Endpoint.shutDown()	Shutdown this Endpoint
void	EndpointBase.shutDown()
void	ManagedRepositoryEndpoint.shutDown()
long	Endpoint.size()	Returns the size of the given repository, i.e.
long	EndpointBase.size()

Uses of RepositoryException in org.eclipse.rdf4j.federated.evaluation

Methods in org.eclipse.rdf4j.federated.evaluation that throw RepositoryException

Modifier and Type	Method	Description
abstract CloseableIteration<BindingSet>	FederationEvalStrategy.evaluateExclusiveGroup(ExclusiveGroup group, BindingSet bindings)
CloseableIteration<BindingSet>	SailFederationEvalStrategy.evaluateExclusiveGroup(ExclusiveGroup group, BindingSet bindings)
CloseableIteration<BindingSet>	SparqlFederationEvalStrategy.evaluateExclusiveGroup(ExclusiveGroup group, BindingSet bindings)
protected CloseableIteration<BindingSet>	FederationEvalStrategy.evaluateExclusiveTupleExpr(ExclusiveTupleExpr expr, BindingSet bindings)	Evaluate an ExclusiveTupleExpr.
CloseableIteration<Statement>	FederationEvalStrategy.getStatements(QueryInfo queryInfo, Resource subj, IRI pred, Value obj, Resource... contexts)	Retrieve the statements matching the provided subject, predicate and object value from the federation members.
CloseableIteration<Statement>	SailTripleSource.getStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)
CloseableIteration<BindingSet>	SailTripleSource.getStatements(StatementPattern stmt, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)
CloseableIteration<BindingSet>	SailTripleSource.getStatements(TupleExpr preparedQuery, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)
CloseableIteration<Statement>	SparqlTripleSource.getStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)
CloseableIteration<BindingSet>	SparqlTripleSource.getStatements(StatementPattern stmt, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)
CloseableIteration<BindingSet>	SparqlTripleSource.getStatements(TupleExpr preparedQuery, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)
CloseableIteration<BindingSet>	TripleSource.getStatements(String preparedQuery, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)	Evaluate the prepared query (SPARQL query as String) on the provided endpoint.
CloseableIteration<BindingSet>	TripleSource.getStatements(String preparedQuery, BindingSet queryBindings, QueryType queryType, QueryInfo queryInfo)	Evaluate a given SPARQL query of the provided query type at the given source.
CloseableIteration<Statement>	TripleSource.getStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)	Return the statements matching the given pattern as a Statement iteration.
CloseableIteration<BindingSet>	TripleSource.getStatements(StatementPattern stmt, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)	Evaluate the query expression on the provided endpoint.
CloseableIteration<BindingSet>	TripleSource.getStatements(TupleExpr preparedQuery, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)	Evaluate the prepared query in its internal representation on the provided endpoint.
CloseableIteration<BindingSet>	TripleSourceBase.getStatements(String preparedQuery, BindingSet bindings, FilterValueExpr filterExpr, QueryInfo queryInfo)
CloseableIteration<BindingSet>	TripleSourceBase.getStatements(String preparedQuery, BindingSet queryBindings, QueryType queryType, QueryInfo queryInfo)
boolean	SailTripleSource.hasStatements(StatementPattern stmt, BindingSet bindings, QueryInfo queryInfo, Dataset dataset)
boolean	SparqlTripleSource.hasStatements(ExclusiveTupleExpr expr, BindingSet bindings)
boolean	SparqlTripleSource.hasStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)
boolean	SparqlTripleSource.hasStatements(StatementPattern stmt, BindingSet bindings, QueryInfo queryInfo, Dataset dataset)
boolean	TripleSource.hasStatements(ExclusiveTupleExpr expr, BindingSet bindings)	Check if the repository can return results for the given ExclusiveTupleExpr, e.g.
boolean	TripleSource.hasStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)	Check if the repository can return results for the given triple pattern represented by subj, pred and obj
boolean	TripleSource.hasStatements(StatementPattern stmt, BindingSet bindings, QueryInfo queryInfo, Dataset dataset)	Check if the provided statement can return results.
boolean	TripleSourceBase.hasStatements(ExclusiveTupleExpr group, BindingSet bindings)
boolean	TripleSourceBase.hasStatements(Resource subj, IRI pred, Value obj, QueryInfo queryInfo, Resource... contexts)
protected QueryEvaluationStep	FederationEvalStrategy.prepareExclusiveTupleExpr(ExclusiveTupleExpr expr, QueryEvaluationContext context)

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

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

Modifier and Type	Method	Description
FedXRepositoryConnection	FedXRepository.getConnection()
void	FedXRepositoryWrapper.init()
protected void	FedXRepository.initializeInternal()
Update	FedXRepositoryConnection.prepareUpdate(QueryLanguage ql, String updateString, String baseURI)
void	FedXRepositoryWrapper.shutDown()
protected void	FedXRepository.shutDownInternal()

Uses of RepositoryException in org.eclipse.rdf4j.federated.write

Methods in org.eclipse.rdf4j.federated.write that throw RepositoryException

Modifier and Type	Method	Description
void	RepositoryWriteStrategy.addStatement(Resource subj, IRI pred, Value obj, Resource... contexts)
void	WriteStrategy.addStatement(Resource subj, IRI pred, Value obj, Resource... contexts)	Add a statement
void	ReadOnlyWriteStrategy.begin()
void	RepositoryWriteStrategy.begin()
void	WriteStrategy.begin()	Begin a transaction.
void	ReadOnlyWriteStrategy.clear(Resource... contexts)
void	RepositoryWriteStrategy.clear(Resource... contexts)
void	WriteStrategy.clear(Resource... contexts)
void	ReadOnlyWriteStrategy.clearNamespaces()
void	RepositoryWriteStrategy.clearNamespaces()
void	WriteStrategy.clearNamespaces()
void	ReadOnlyWriteStrategy.close()
void	RepositoryWriteStrategy.close()
void	WriteStrategy.close()	Close this write strategy (e.g.
void	ReadOnlyWriteStrategy.commit()
void	RepositoryWriteStrategy.commit()
void	WriteStrategy.commit()	Commit a transaction.
void	ReadOnlyWriteStrategy.removeStatement(Resource subj, IRI pred, Value obj, Resource... contexts)
void	RepositoryWriteStrategy.removeStatement(Resource subj, IRI pred, Value obj, Resource... contexts)
void	WriteStrategy.removeStatement(Resource subj, IRI pred, Value obj, Resource... contexts)	Remove a statement
void	ReadOnlyWriteStrategy.rollback()
void	RepositoryWriteStrategy.rollback()
void	WriteStrategy.rollback()	Rollback a transaction.
void	ReadOnlyWriteStrategy.setTransactionSettings(TransactionSetting... transactionSettings)
void	RepositoryWriteStrategy.setTransactionSettings(TransactionSetting... transactionSettings)
void	WriteStrategy.setTransactionSettings(TransactionSetting... transactionSettings)	Assign TransactionSettings to be used for the next transaction.

Uses of RepositoryException in org.eclipse.rdf4j.http.client

Methods in org.eclipse.rdf4j.http.client that throw RepositoryException

Modifier and Type	Method	Description
void	RDF4JProtocolSession.addData(InputStream contents, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RDF4JProtocolSession.clearNamespaces()
void	RDF4JProtocolSession.createRepository(RepositoryConfig config)	Create a new repository.
void	RDF4JProtocolSession.deleteRepository(String repositoryID)
protected TupleQueryResult	SPARQLProtocolSession.getBackgroundTupleQueryResult(org.apache.http.client.methods.HttpUriRequest method, WeakReference<?> callerRef)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
TupleQueryResult	RDF4JProtocolSession.getContextIDs()
void	RDF4JProtocolSession.getContextIDs(TupleQueryResultHandler handler)
protected ErrorInfo	SPARQLProtocolSession.getErrorInfo(org.apache.http.HttpResponse response)
String	RDF4JProtocolSession.getNamespace(String prefix)
TupleQueryResult	RDF4JProtocolSession.getNamespaces()
void	RDF4JProtocolSession.getNamespaces(TupleQueryResultHandler handler)
protected void	SPARQLProtocolSession.getRDF(org.apache.http.client.methods.HttpUriRequest method, RDFHandler handler, boolean requireContext)	Parse the response in this thread using the provided RDFHandler.
protected GraphQueryResult	SPARQLProtocolSession.getRDFBackground(org.apache.http.client.methods.HttpUriRequest method, boolean requireContext, WeakReference<?> callerRef)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
void	RDF4JProtocolSession.getRepositoryConfig(StatementCollector statementCollector)	Retrieve configuration of the current repository and send it to the supplied StatementCollector
TupleQueryResult	RDF4JProtocolSession.getRepositoryList()
void	RDF4JProtocolSession.getRepositoryList(TupleQueryResultHandler handler)
String	RDF4JProtocolSession.getServerProtocol()
void	RDF4JProtocolSession.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)
protected void	SPARQLProtocolSession.getTupleQueryResult(org.apache.http.client.methods.HttpUriRequest method, TupleQueryResultHandler handler)	Parse the response in this thread using the provided TupleQueryResultHandler.
void	RDF4JProtocolSession.removeData(InputStream contents, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RDF4JProtocolSession.removeNamespacePrefix(String prefix)
boolean	SPARQLProtocolSession.sendBooleanQuery(QueryLanguage ql, String query, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, Binding... bindings)
boolean	SPARQLProtocolSession.sendBooleanQuery(QueryLanguage ql, String query, Dataset dataset, boolean includeInferred, Binding... bindings)
GraphQueryResult	SPARQLProtocolSession.sendGraphQuery(QueryLanguage ql, String query, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, WeakReference<?> callerRef, Binding... bindings)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
void	SPARQLProtocolSession.sendGraphQuery(QueryLanguage ql, String query, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, RDFHandler handler, Binding... bindings)
GraphQueryResult	SPARQLProtocolSession.sendGraphQuery(QueryLanguage ql, String query, Dataset dataset, boolean includeInferred, WeakReference<?> callerRef, Binding... bindings)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
void	SPARQLProtocolSession.sendGraphQuery(QueryLanguage ql, String query, Dataset dataset, boolean includeInferred, RDFHandler handler, Binding... bindings)
void	RDF4JProtocolSession.sendTransaction(Iterable<? extends TransactionOperation> txn)	Deprecated. since 2.8.0
TupleQueryResult	SPARQLProtocolSession.sendTupleQuery(QueryLanguage ql, String query, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, WeakReference<?> callerRef, Binding... bindings)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
void	SPARQLProtocolSession.sendTupleQuery(QueryLanguage ql, String query, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, TupleQueryResultHandler handler, Binding... bindings)
TupleQueryResult	SPARQLProtocolSession.sendTupleQuery(QueryLanguage ql, String query, Dataset dataset, boolean includeInferred, WeakReference<?> callerRef, Binding... bindings)	Deprecated. WeakReferenceinvalid input: '<'?> callerRef argument will be removed
void	SPARQLProtocolSession.sendUpdate(QueryLanguage ql, String update, String baseURI, Dataset dataset, boolean includeInferred, int maxQueryTime, Binding... bindings)
void	SPARQLProtocolSession.sendUpdate(QueryLanguage ql, String update, String baseURI, Dataset dataset, boolean includeInferred, Binding... bindings)
void	RDF4JProtocolSession.setNamespacePrefix(String prefix, String name)
long	RDF4JProtocolSession.size(Resource... contexts)
void	RDF4JProtocolSession.updateRepository(RepositoryConfig config)	Update the config of an existing repository.
protected void	RDF4JProtocolSession.upload(InputStream contents, String baseURI, RDFFormat dataFormat, boolean overwrite, boolean preserveNodeIds, Protocol.Action action, Resource... contexts)
void	RDF4JProtocolSession.upload(InputStream contents, String baseURI, RDFFormat dataFormat, boolean overwrite, boolean preserveNodeIds, Resource... contexts)
protected void	RDF4JProtocolSession.upload(Reader contents, String baseURI, RDFFormat dataFormat, boolean overwrite, boolean preserveNodeIds, Protocol.Action action, Resource... contexts)
void	RDF4JProtocolSession.upload(Reader contents, String baseURI, RDFFormat dataFormat, boolean overwrite, boolean preserveNodeIds, Resource... contexts)
protected void	RDF4JProtocolSession.upload(org.apache.http.HttpEntity reqEntity, String baseURI, boolean overwrite, boolean preserveNodeIds, Protocol.Action action, Resource... contexts)

Uses of RepositoryException in org.eclipse.rdf4j.http.protocol

Subclasses of RepositoryException in org.eclipse.rdf4j.http.protocol

Modifier and Type	Class	Description
class	UnauthorizedException

Uses of RepositoryException in org.eclipse.rdf4j.http.protocol.transaction.operations

Methods in org.eclipse.rdf4j.http.protocol.transaction.operations that throw RepositoryException

Modifier and Type	Method	Description
void	AddStatementOperation.execute(RepositoryConnection con)
void	ClearNamespacesOperation.execute(RepositoryConnection con)
void	ClearOperation.execute(RepositoryConnection con)
void	RemoveNamespaceOperation.execute(RepositoryConnection con)
void	RemoveStatementsOperation.execute(RepositoryConnection con)
void	SetNamespaceOperation.execute(RepositoryConnection con)
void	SPARQLUpdateOperation.execute(RepositoryConnection con)
void	TransactionOperation.execute(RepositoryConnection con)	Executes this operation on the supplied connection.

Uses of RepositoryException in org.eclipse.rdf4j.http.server.repository

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

Modifier and Type	Method	Description
RepositoryConnection	RepositoryConfigRepository.getConnection()
protected void	RepositoryConfigRepository.initializeInternal()
boolean	RepositoryConfigRepository.isWritable()
protected void	RepositoryConfigRepository.shutDownInternal()

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, Resource... contexts)	Adds RDF data from the specified file to a specific contexts in the repository.
default void	RepositoryConnection.add(File file, Resource... contexts)	Adds RDF data from the specified file to a specific contexts in the repository.
default void	RepositoryConnection.add(File file, RDFFormat dataFormat, 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, 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, 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, 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, Resource... contexts)	Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
void	RepositoryConnection.add(Iterable<? extends Statement> statements, 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, 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, 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, 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(CloseableIteration<? extends Statement> statements, Resource... contexts)	Adds the supplied statements to this repository, optionally to one or more named contexts.
void	RepositoryConnection.add(Resource subject, IRI predicate, Value object, 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(Statement st, Resource... contexts)	Adds the supplied statement to this repository, optionally to one or more named contexts.
default void	RepositoryConnection.add(RepositoryResult<Statement> statements, 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(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, Resource... contexts)	Exports all explicit statements in the specified contexts to the supplied RDFHandler.
void	RepositoryConnection.exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, 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<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<Namespace>	RepositoryConnection.getNamespaces()	Gets all declared namespaces as a RepositoryResult of Namespace objects.
Repository	RepositoryResolver.getRepository(String memberID)
RepositoryResult<Statement>	RepositoryConnection.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)	Gets all statements with a specific subject, predicate and/or object from the repository.
default RepositoryResult<Statement>	RepositoryConnection.getStatements(Resource subj, IRI pred, Value obj, 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(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)	Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
boolean	RepositoryConnection.hasStatement(Statement st, boolean includeInferred, 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 Statement> statements, Resource... contexts)	Removes the supplied statements from the specified contexts in this repository.
void	RepositoryConnection.remove(CloseableIteration<? extends Statement> statements, 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(Resource subject, IRI predicate, Value object, 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(Statement st, Resource... contexts)	Removes the supplied statement from the specified contexts in the repository.
default void	RepositoryConnection.remove(RepositoryResult<Statement> statements, 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(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, Resource... contexts)
void	AbstractRepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	AbstractRepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	AbstractRepositoryConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	AbstractRepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	AbstractRepositoryConnection.add(CloseableIteration<? extends Statement> statements, Resource... contexts)
void	AbstractRepositoryConnection.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	AbstractRepositoryConnection.add(Statement st, Resource... contexts)
void	RepositoryConnectionWrapper.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RepositoryConnectionWrapper.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RepositoryConnectionWrapper.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RepositoryConnectionWrapper.add(Iterable<? extends Statement> statements, Resource... contexts)
void	RepositoryConnectionWrapper.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	RepositoryConnectionWrapper.add(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	RepositoryConnectionWrapper.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	RepositoryConnectionWrapper.add(Statement st, Resource... contexts)
protected abstract void	AbstractRepositoryConnection.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
protected void	AbstractRepositoryConnection.addWithoutCommit(Statement st, Resource... contexts)
protected void	RepositoryConnectionWrapper.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	AbstractRepositoryConnection.begin(IsolationLevel level)
void	RepositoryConnectionWrapper.begin()
void	RepositoryConnectionWrapper.begin(IsolationLevel level)
void	AbstractRepositoryConnection.clear(Resource... contexts)
void	RepositoryConnectionWrapper.clear(Resource... contexts)
void	RepositoryConnectionWrapper.clearNamespaces()
void	AbstractRepositoryConnection.close()
void	RepositoryConnectionWrapper.close()
void	RepositoryConnectionWrapper.commit()
protected final void	AbstractRepositoryConnection.conditionalCommit(boolean condition)	Invokes RepositoryConnection.commit() if supplied boolean condition is true.
protected final void	AbstractRepositoryConnection.conditionalRollback(boolean condition)	Invokes RepositoryConnection.rollback() if supplied boolean condition is true.
void	AbstractRepositoryConnection.export(RDFHandler handler, Resource... contexts)
void	RepositoryConnectionWrapper.exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)
protected void	RepositoryConnectionWrapper.exportStatements(RepositoryResult<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<Resource>	RepositoryConnectionWrapper.getContextIDs()
abstract String	AbstractRepositoryConnection.getNamespace(String prefix)
String	RepositoryConnectionWrapper.getNamespace(String prefix)
RepositoryResult<Namespace>	RepositoryConnectionWrapper.getNamespaces()
RepositoryResult<Statement>	RepositoryConnectionWrapper.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	AbstractRepositoryConnection.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	AbstractRepositoryConnection.hasStatement(Statement st, boolean includeInferred, Resource... contexts)
boolean	RepositoryConnectionWrapper.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	RepositoryConnectionWrapper.hasStatement(Statement st, boolean includeInferred, Resource... contexts)
final 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 Statement> statements, Resource... contexts)
void	AbstractRepositoryConnection.remove(CloseableIteration<? extends Statement> statements, Resource... contexts)
void	AbstractRepositoryConnection.remove(Resource subject, IRI predicate, Value object, Resource... contexts)
void	AbstractRepositoryConnection.remove(Statement st, Resource... contexts)
void	RepositoryConnectionWrapper.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	RepositoryConnectionWrapper.remove(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	RepositoryConnectionWrapper.remove(Resource subject, IRI predicate, Value object, Resource... contexts)
void	RepositoryConnectionWrapper.remove(Statement st, Resource... contexts)
void	RepositoryConnectionWrapper.removeNamespace(String prefix)
protected abstract void	AbstractRepositoryConnection.removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
protected void	AbstractRepositoryConnection.removeWithoutCommit(Statement st, Resource... contexts)
protected void	RepositoryConnectionWrapper.removeWithoutCommit(Resource subject, IRI predicate, Value object, 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)
final void	AbstractRepository.shutDown()
void	RepositoryWrapper.shutDown()
protected abstract void	AbstractRepository.shutDownInternal()
long	RepositoryConnectionWrapper.size(Resource... contexts)
protected final 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 Resource	RepositoryConfigUtil.getContext(RepositoryConnection con, String repositoryID)	Deprecated.
static RepositoryConfig	RepositoryConfigUtil.getRepositoryConfig(Repository repository, String repositoryID)	Deprecated.
static Set<String>	RepositoryConfigUtil.getRepositoryIDs(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.contextaware

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

Modifier and Type	Method	Description
void	ContextAwareConnection.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(File file, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(InputStream in, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(Reader reader, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	ContextAwareConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(URL url, RDFFormat dataFormat, Resource... contexts)
void	ContextAwareConnection.add(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	ContextAwareConnection.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	ContextAwareConnection.add(Statement st, Resource... contexts)
void	ContextAwareConnection.clear(Resource... contexts)
void	ContextAwareConnection.export(RDFHandler handler, Resource... contexts)
void	ContextAwareConnection.exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)
void	ContextAwareConnection.exportStatements(Resource subj, IRI pred, Value obj, RDFHandler handler, Resource... contexts)	Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.
ContextAwareConnection	ContextAwareRepository.getConnection()
RepositoryResult<Statement>	ContextAwareConnection.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
RepositoryResult<Statement>	ContextAwareConnection.getStatements(Resource subj, IRI pred, Value obj, Resource... contexts)	Gets all statements with a specific subject, predicate and/or object from the repository.
boolean	ContextAwareConnection.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	ContextAwareConnection.hasStatement(Resource subj, IRI pred, Value obj, Resource... contexts)	Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
boolean	ContextAwareConnection.hasStatement(Statement st, boolean includeInferred, Resource... contexts)
boolean	ContextAwareConnection.hasStatement(Statement st, Resource... contexts)	Checks whether the repository contains the specified statement, optionally in the specified contexts.
protected boolean	ContextAwareConnection.isDelegatingRemove()
BooleanQuery	ContextAwareConnection.prepareBooleanQuery(QueryLanguage ql, String query)
BooleanQuery	ContextAwareConnection.prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)
GraphQuery	ContextAwareConnection.prepareGraphQuery(String query)
GraphQuery	ContextAwareConnection.prepareGraphQuery(QueryLanguage ql, String query)
GraphQuery	ContextAwareConnection.prepareGraphQuery(QueryLanguage ql, String query, String baseURI)
Query	ContextAwareConnection.prepareQuery(String query)
Query	ContextAwareConnection.prepareQuery(QueryLanguage ql, String query)
Query	ContextAwareConnection.prepareQuery(QueryLanguage ql, String query, String baseURI)
TupleQuery	ContextAwareConnection.prepareTupleQuery(String query)
TupleQuery	ContextAwareConnection.prepareTupleQuery(QueryLanguage ql, String query)
TupleQuery	ContextAwareConnection.prepareTupleQuery(QueryLanguage ql, String query, String baseURI)
Update	ContextAwareConnection.prepareUpdate(String query)
Update	ContextAwareConnection.prepareUpdate(QueryLanguage ql, String query)
Update	ContextAwareConnection.prepareUpdate(QueryLanguage ql, String update, String baseURI)
void	ContextAwareConnection.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	ContextAwareConnection.remove(CloseableIteration<? extends Statement> statementIter, Resource... contexts)	Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
void	ContextAwareConnection.remove(Resource subject, IRI predicate, Value object, Resource... contexts)	Removes the statement with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
void	ContextAwareConnection.remove(Statement st, Resource... contexts)	Removes the supplied statement from the specified contexts in the repository.
protected void	ContextAwareConnection.removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
long	ContextAwareConnection.size(Resource... contexts)	Returns the number of (explicit) statements that are in the specified contexts in this repository.

Constructors in org.eclipse.rdf4j.repository.contextaware that throw RepositoryException

Modifier	Constructor	Description
	ContextAwareConnection(Repository repository)
	ContextAwareConnection(RepositoryConnection connection)
	ContextAwareConnection(Repository repository, RepositoryConnection connection)

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

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

Modifier and Type	Method	Description
RepositoryConnection	DatasetRepository.getConnection()
void	DatasetRepository.loadDataset(URL url, IRI context, ParserConfig config)	Inspects if the dataset at the supplied URL location has been modified since the last load into this repository and if so loads it into the supplied context.
BooleanQuery	DatasetRepositoryConnection.prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)
GraphQuery	DatasetRepositoryConnection.prepareGraphQuery(QueryLanguage ql, String query, String baseURI)
Query	DatasetRepositoryConnection.prepareQuery(QueryLanguage ql, String query, String baseURI)
TupleQuery	DatasetRepositoryConnection.prepareTupleQuery(QueryLanguage ql, String query, String baseURI)

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

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

Modifier and Type	Method	Description
NotifyingRepositoryConnection	NotifyingRepository.getConnection()	Opens a connection to this repository that can be used for querying and updating the contents of the repository.

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

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

Modifier and Type	Method	Description
void	InterceptingRepositoryConnectionWrapper.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	NotifyingRepositoryConnectionWrapper.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	InterceptingRepositoryConnectionWrapper.begin()
void	NotifyingRepositoryConnectionWrapper.begin()
void	InterceptingRepositoryConnectionWrapper.clear(Resource... contexts)
void	NotifyingRepositoryConnectionWrapper.clear(Resource... contexts)
void	InterceptingRepositoryConnectionWrapper.clearNamespaces()
void	NotifyingRepositoryConnectionWrapper.clearNamespaces()
void	InterceptingRepositoryConnectionWrapper.close()
void	NotifyingRepositoryConnectionWrapper.close()
void	InterceptingRepositoryConnectionWrapper.commit()
void	NotifyingRepositoryConnectionWrapper.commit()
InterceptingRepositoryConnection	InterceptingRepositoryWrapper.getConnection()
NotifyingRepositoryConnection	NotifyingRepositoryWrapper.getConnection()
void	InterceptingRepositoryWrapper.init()
void	NotifyingRepositoryWrapper.init()
Update	InterceptingRepositoryConnectionWrapper.prepareUpdate(QueryLanguage ql, String update, String baseURI)
Update	NotifyingRepositoryConnectionWrapper.prepareUpdate(QueryLanguage ql, String update, String baseURI)
void	InterceptingRepositoryConnectionWrapper.removeNamespace(String prefix)
void	NotifyingRepositoryConnectionWrapper.removeNamespace(String prefix)
void	InterceptingRepositoryConnectionWrapper.removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	NotifyingRepositoryConnectionWrapper.removeWithoutCommit(Resource subj, IRI pred, Value obj, Resource... ctx)
void	InterceptingRepositoryConnectionWrapper.rollback()
void	NotifyingRepositoryConnectionWrapper.rollback()
void	InterceptingRepositoryConnectionWrapper.setAutoCommit(boolean autoCommit)	Deprecated.
void	NotifyingRepositoryConnectionWrapper.setAutoCommit(boolean autoCommit)	Deprecated.
void	InterceptingRepositoryConnectionWrapper.setNamespace(String prefix, String name)
void	NotifyingRepositoryConnectionWrapper.setNamespace(String prefix, String name)
void	InterceptingRepositoryWrapper.shutDown()
void	NotifyingRepositoryWrapper.shutDown()

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

Methods in org.eclipse.rdf4j.repository.http that return RepositoryException

Modifier and Type	Method	Description
RepositoryException	HTTPQueryEvaluationException.getCauseAsRepositoryException()
RepositoryException	HTTPUpdateExecutionException.getCauseAsRepositoryException()

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

Modifier and Type	Method	Description
RepositoryConnection	HTTPRepository.getConnection()
protected void	HTTPRepository.initializeInternal()
boolean	HTTPRepository.isWritable()
protected void	HTTPRepository.shutDownInternal()

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

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

Modifier and Type	Method	Description
void	LocalRepositoryManager.addRepositoryConfig(RepositoryConfig config)
void	RemoteRepositoryManager.addRepositoryConfig(RepositoryConfig config)
abstract void	RepositoryManager.addRepositoryConfig(RepositoryConfig config)	Adds or updates the configuration of a repository to the manager.
protected Repository	LocalRepositoryManager.createRepository(String id)
protected Repository	RemoteRepositoryManager.createRepository(String id)	Creates and initializes the repository with the specified ID.
protected abstract Repository	RepositoryManager.createRepository(String id)	Creates and initializes the repository with the specified ID.
Collection<Repository>	RepositoryManager.getAllRepositories()	Returns all configured repositories.
List<RepositoryInfo>	LocalRepositoryManager.getAllRepositoryInfos()
Collection<RepositoryInfo>	RemoteRepositoryManager.getAllRepositoryInfos()
abstract Collection<RepositoryInfo>	RepositoryManager.getAllRepositoryInfos()	Retrieve meta information of all configured repositories.
Collection<RepositoryInfo>	RepositoryManager.getAllRepositoryInfos(boolean skipSystemRepo)	Deprecated. Use RepositoryManager.getAllRepositoryInfos() instead.
Collection<RepositoryInfo>	RepositoryManager.getAllUserRepositoryInfos()	Deprecated. Use RepositoryManager.getAllRepositoryInfos() instead.
static RemoteRepositoryManager	RemoteRepositoryManager.getInstance(String serverURL)	Creates an initialized RemoteRepositoryManager with the specified server URL.
static RemoteRepositoryManager	RemoteRepositoryManager.getInstance(String serverURL, String username, String password)	Creates an initialized RemoteRepositoryManager with the specified server URL and credentials.
String	RepositoryManager.getNewRepositoryID(String baseName)	Generates an ID for a new repository based on the specified base name.
Repository	RepositoryManager.getRepository(String identity)	Gets the repository that is known by the specified ID from this manager.
static Repository	RepositoryProvider.getRepository(String url)	Retrieves a (new or existing) Repository object for the supplied repository URL.
RepositoryConfig	RemoteRepositoryManager.getRepositoryConfig(String id)
abstract RepositoryConfig	RepositoryManager.getRepositoryConfig(String repositoryID)
Set<String>	RepositoryManager.getRepositoryIDs()	Get the IDs of all available repositories.
RepositoryInfo	RepositoryManager.getRepositoryInfo(String id)	Gets the repository that is known by the specified ID from this manager.
static LocalRepositoryManager	RepositoryProvider.getRepositoryManager(File dir)	Creates a LocalRepositoryManager, if not already created, that will be shutdown when the JVM exits cleanly.
static RepositoryManager	RepositoryProvider.getRepositoryManager(String url)	Creates a RepositoryManager, if not already created, that will be shutdown when the JVM exits cleanly.
static RepositoryManager	RepositoryProvider.getRepositoryManagerOfRepository(String url)	Retrieves the RepositoryManager that will be used for the given repository URL.
boolean	RepositoryManager.hasRepositoryConfig(String repositoryID)
void	RepositoryManager.init()	Initializes the repository manager.
boolean	RepositoryManager.isSafeToRemove(String repositoryID)	Checks on whether the given repository is referred to by a ProxyRepository configuration.
boolean	LocalRepositoryManager.removeRepository(String repositoryID)
boolean	RemoteRepositoryManager.removeRepository(String repositoryID)
boolean	RepositoryManager.removeRepository(String repositoryID)	Removes the specified repository by deleting its configuration if such a configuration is present, and removing any persistent data associated with the repository.

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

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

Modifier and Type	Method	Description
void	TypeFilteringRepositoryManager.addRepositoryConfig(RepositoryConfig config)
protected Repository	TypeFilteringRepositoryManager.createRepository(String id)
Collection<RepositoryInfo>	TypeFilteringRepositoryManager.getAllRepositoryInfos()
String	TypeFilteringRepositoryManager.getNewRepositoryID(String baseName)
Repository	TypeFilteringRepositoryManager.getRepository(String id)
RepositoryConfig	TypeFilteringRepositoryManager.getRepositoryConfig(String repositoryID)
Set<String>	TypeFilteringRepositoryManager.getRepositoryIDs()
RepositoryInfo	TypeFilteringRepositoryManager.getRepositoryInfo(String id)
boolean	TypeFilteringRepositoryManager.hasRepositoryConfig(String repositoryID)
void	NotifyingLocalRepositoryManager.init()
void	TypeFilteringRepositoryManager.init()
protected boolean	TypeFilteringRepositoryManager.isCorrectType(String repositoryID)

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

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

Modifier and Type	Method	Description
protected void	SailRepositoryConnection.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	SailRepositoryConnection.begin()
void	SailRepositoryConnection.begin(IsolationLevel level)
void	SailRepositoryConnection.clear(Resource... contexts)
void	SailRepositoryConnection.clearNamespaces()
void	SailRepositoryConnection.close()
void	SailRepositoryConnection.commit()
void	SailRepositoryConnection.exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)
RepositoryConnection	ProxyRepository.getConnection()
SailRepositoryConnection	SailRepository.getConnection()
RepositoryResult<Resource>	SailRepositoryConnection.getContextIDs()
String	SailRepositoryConnection.getNamespace(String prefix)
RepositoryResult<Namespace>	SailRepositoryConnection.getNamespaces()
RepositoryResult<Statement>	SailRepositoryConnection.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	SailRepositoryConnection.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
protected void	ProxyRepository.initializeInternal()
protected void	SailRepository.initializeInternal()
boolean	SailRepositoryConnection.isEmpty()
boolean	SailRepositoryConnection.isOpen()
boolean	ProxyRepository.isWritable()
boolean	SailRepository.isWritable()
void	SailRepositoryConnection.prepare()
Update	SailRepositoryConnection.prepareUpdate(QueryLanguage ql, String update, String baseURI)
void	SailRepositoryConnection.removeNamespace(String prefix)
protected void	SailRepositoryConnection.removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
void	SailRepositoryConnection.rollback()
void	SailRepositoryConnection.setNamespace(String prefix, String name)
protected void	ProxyRepository.shutDownInternal()
protected void	SailRepository.shutDownInternal()
long	SailRepositoryConnection.size(Resource... contexts)

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

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

Modifier and Type	Method	Description
Repository	RepositoryResolver.getRepository(String memberID)	Deprecated.

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

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

Modifier and Type	Method	Description
void	SPARQLConnection.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	SPARQLConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	SPARQLConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	SPARQLConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	SPARQLConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	SPARQLConnection.add(Statement st, Resource... contexts)
protected void	SPARQLConnection.addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
protected void	SPARQLConnection.addWithoutCommit(Statement st, Resource... contexts)
void	SPARQLConnection.begin()
void	SPARQLConnection.clear(Resource... contexts)
void	SPARQLConnection.clearNamespaces()
void	SPARQLConnection.close()
void	SPARQLConnection.commit()
void	SPARQLConnection.exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)
RepositoryConnection	SPARQLRepository.getConnection()
RepositoryResult<Resource>	SPARQLConnection.getContextIDs()
String	SPARQLConnection.getNamespace(String prefix)
RepositoryResult<Namespace>	SPARQLConnection.getNamespaces()
RepositoryResult<Statement>	SPARQLConnection.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	SPARQLConnection.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
protected void	SPARQLRepository.initializeInternal()
boolean	SPARQLConnection.isActive()
boolean	SPARQLConnection.isEmpty()
boolean	SPARQLRepository.isWritable()
void	SPARQLConnection.prepare()
BooleanQuery	SPARQLConnection.prepareBooleanQuery(QueryLanguage ql, String query, String base)
GraphQuery	SPARQLConnection.prepareGraphQuery(QueryLanguage ql, String query, String base)
Query	SPARQLConnection.prepareQuery(QueryLanguage ql, String query, String base)
TupleQuery	SPARQLConnection.prepareTupleQuery(QueryLanguage ql, String query, String base)
Update	SPARQLConnection.prepareUpdate(QueryLanguage ql, String update, String baseURI)
void	SPARQLConnection.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	SPARQLConnection.remove(Statement st, Resource... contexts)
void	SPARQLConnection.removeNamespace(String prefix)
protected void	SPARQLConnection.removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)
protected void	SPARQLConnection.removeWithoutCommit(Statement st, Resource... contexts)
void	SPARQLConnection.rollback()
void	SPARQLConnection.setNamespace(String prefix, String name)
protected void	SPARQLRepository.shutDownInternal()
long	SPARQLConnection.size(Resource... contexts)

Uses of RepositoryException in org.eclipse.rdf4j.repository.sparql.federation

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

Modifier and Type	Method	Description
protected RepositoryConnection	RepositoryFederatedService.getConnection()	Retrieve a (re-usable) connection.

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, Resource head, Consumer<Statement> collectionConsumer, 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 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<Statement>> C	Connections.getRDFCollection(RepositoryConnection conn, Resource head, C statementCollection, Resource... contexts)	Retrieve all Statements that together form the RDF Collection starting with the supplied starting resource.
static Optional<Statement>	Connections.getStatement(RepositoryConnection conn, Resource subject, IRI predicate, Value object, 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.

Uses of RepositoryException in org.eclipse.rdf4j.spring.operationlog

Methods in org.eclipse.rdf4j.spring.operationlog that throw RepositoryException

Modifier and Type	Method	Description
void	LoggingRepositoryConnection.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	LoggingRepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	LoggingRepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	LoggingRepositoryConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	LoggingRepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	LoggingRepositoryConnection.add(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	LoggingRepositoryConnection.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	LoggingRepositoryConnection.add(Statement st, Resource... contexts)
void	LoggingRepositoryConnection.add(RepositoryResult<Statement> statements, Resource... contexts)
void	LoggingRepositoryConnection.clear(Resource... contexts)
RepositoryResult<Statement>	LoggingRepositoryConnection.getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
RepositoryResult<Statement>	LoggingRepositoryConnection.getStatements(Resource subj, IRI pred, Value obj, Resource... contexts)
boolean	LoggingRepositoryConnection.hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
boolean	LoggingRepositoryConnection.hasStatement(Statement st, boolean includeInferred, Resource... contexts)
GraphQuery	LoggingRepositoryConnection.prepareGraphQuery(String query)
GraphQuery	LoggingRepositoryConnection.prepareGraphQuery(QueryLanguage ql, String query)
GraphQuery	LoggingRepositoryConnection.prepareGraphQuery(QueryLanguage ql, String queryString, String baseURI)
TupleQuery	LoggingRepositoryConnection.prepareTupleQuery(String query)
TupleQuery	LoggingRepositoryConnection.prepareTupleQuery(QueryLanguage ql, String query)
TupleQuery	LoggingRepositoryConnection.prepareTupleQuery(QueryLanguage ql, String queryString, String baseURI)
Update	LoggingRepositoryConnection.prepareUpdate(QueryLanguage ql, String updateString, String baseURI)
void	LoggingRepositoryConnection.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	LoggingRepositoryConnection.remove(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	LoggingRepositoryConnection.remove(Resource subject, IRI predicate, Value object, Resource... contexts)
void	LoggingRepositoryConnection.remove(Statement st, Resource... contexts)
void	LoggingRepositoryConnection.remove(RepositoryResult<Statement> statements, Resource... contexts)
void	LoggingRepositoryConnection.removeNamespace(String prefix)
long	LoggingRepositoryConnection.size(Resource... contexts)

Uses of RepositoryException in org.eclipse.rdf4j.spring.pool

Methods in org.eclipse.rdf4j.spring.pool that throw RepositoryException

Modifier and Type	Method	Description
void	PooledRepositoryConnection.close()

Uses of RepositoryException in org.eclipse.rdf4j.spring.resultcache

Methods in org.eclipse.rdf4j.spring.resultcache that throw RepositoryException

Modifier and Type	Method	Description
void	CachingRepositoryConnection.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	CachingRepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	CachingRepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	CachingRepositoryConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	CachingRepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	CachingRepositoryConnection.add(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	CachingRepositoryConnection.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	CachingRepositoryConnection.add(Statement st, Resource... contexts)
void	CachingRepositoryConnection.clear(Resource... contexts)
void	CachingRepositoryConnection.close()
GraphQuery	CachingRepositoryConnection.prepareGraphQuery(QueryLanguage ql, String queryString, String baseURI)
TupleQuery	CachingRepositoryConnection.prepareTupleQuery(QueryLanguage ql, String queryString, String baseURI)
Update	CachingRepositoryConnection.prepareUpdate(QueryLanguage ql, String updateString, String baseURI)
void	CachingRepositoryConnection.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	CachingRepositoryConnection.remove(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	CachingRepositoryConnection.remove(Resource subject, IRI predicate, Value object, Resource... contexts)
void	CachingRepositoryConnection.remove(Statement st, Resource... contexts)
void	CachingRepositoryConnection.removeNamespace(String prefix)

Uses of RepositoryException in org.eclipse.rdf4j.spring.tx

Methods in org.eclipse.rdf4j.spring.tx that throw RepositoryException

Modifier and Type	Method	Description
void	TransactionalRepositoryConnection.add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(File file, Resource... contexts)
void	TransactionalRepositoryConnection.add(File file, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(InputStream in, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(Reader reader, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(Iterable<? extends Statement> statements, Resource... contexts)
void	TransactionalRepositoryConnection.add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(URL url, Resource... contexts)
void	TransactionalRepositoryConnection.add(URL url, RDFFormat dataFormat, Resource... contexts)
void	TransactionalRepositoryConnection.add(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	TransactionalRepositoryConnection.add(Resource subject, IRI predicate, Value object, Resource... contexts)
void	TransactionalRepositoryConnection.add(Statement st, Resource... contexts)
void	TransactionalRepositoryConnection.add(RepositoryResult<Statement> statements, Resource... contexts)
void	TransactionalRepositoryConnection.clear(Resource... contexts)
void	TransactionalRepositoryConnection.clearNamespaces()
Update	TransactionalRepositoryConnection.prepareUpdate(String update)
void	TransactionalRepositoryConnection.remove(Iterable<? extends Statement> statements, Resource... contexts)
void	TransactionalRepositoryConnection.remove(CloseableIteration<? extends Statement> statementIter, Resource... contexts)
void	TransactionalRepositoryConnection.remove(Resource subject, IRI predicate, Value object, Resource... contexts)
void	TransactionalRepositoryConnection.remove(Statement st, Resource... contexts)
void	TransactionalRepositoryConnection.remove(RepositoryResult<Statement> statements, Resource... contexts)
void	TransactionalRepositoryConnection.removeNamespace(String prefix)
void	TransactionalRepositoryConnection.setNamespace(String prefix, String name)

Uses of RepositoryException in org.eclipse.rdf4j.testsuite.query.parser.sparql

Methods in org.eclipse.rdf4j.testsuite.query.parser.sparql that throw RepositoryException

Modifier and Type	Method	Description
void	SPARQLUpdateTest.contextualInsertDeleteData()
protected void	SPARQLUpdateTest.loadDataset(String datasetFile)

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

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

Modifier and Type	Method	Description
void	RepositoryConnectionTest.testRecoverFromParseError(IsolationLevel level)

Uses of RepositoryException in org.eclipse.rdf4j.testsuite.repository.optimistic

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

Modifier and Type	Method	Description
protected long	IsolationLevelTest.count(RepositoryConnection con, Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)
protected void	IsolationLevelTest.insertTestStatement(RepositoryConnection connection, int i)
protected boolean	IsolationLevelTest.isSupported(IsolationLevels level)
protected Literal	IsolationLevelTest.readLiteral(RepositoryConnection con, IRI subj, IRI pred)

Uses of RepositoryException in org.eclipse.rdf4j.testsuite.sparql

Methods in org.eclipse.rdf4j.testsuite.sparql that throw RepositoryException

Modifier and Type	Method	Description
protected void	AbstractComplianceTest.loadTestData(String dataFile, RepositoryConnection conn, Resource... contexts)

Uses of RepositoryException in org.eclipse.rdf4j.workbench.commands

Methods in org.eclipse.rdf4j.workbench.commands that throw RepositoryException

Modifier and Type	Method	Description
protected void	AddServlet.doPost(WorkbenchRequest req, javax.servlet.http.HttpServletResponse resp, String xslPath)
protected void	ClearServlet.doPost(WorkbenchRequest req, javax.servlet.http.HttpServletResponse resp, String xslPath)
protected void	RemoveServlet.doPost(WorkbenchRequest req, javax.servlet.http.HttpServletResponse resp, String xslPath)
void	AddServlet.service(TupleResultBuilder builder, String xslPath)
void	ClearServlet.service(TupleResultBuilder builder, String xslPath)
protected void	ContextsServlet.service(TupleResultBuilder builder, RepositoryConnection con)
protected void	CreateServlet.service(WorkbenchRequest req, javax.servlet.http.HttpServletResponse resp, String xslPath)	GET requests to this servlet come from the Workbench side bar or from create.xsl form submissions.
void	DeleteServlet.service(TupleResultBuilder builder, String xslPath)	Presents a page where the user can choose a repository ID to delete.
void	InformationServlet.service(TupleResultBuilder builder, String xslPath)
void	NamespacesServlet.service(TupleResultBuilder builder, String xslPath)
void	RemoveServlet.service(TupleResultBuilder builder, String xslPath)
void	RepositoriesServlet.service(TupleResultBuilder builder, String xslPath)
void	SummaryServlet.service(TupleResultBuilder builder, String xslPath)
void	UpdateServlet.service(TupleResultBuilder builder, String xslPath)

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

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

Modifier and Type	Method	Description
boolean	QueryStorage.askExists(HTTPRepository repository, String queryName, String userName)
boolean	QueryStorage.canChange(IRI query, String currentUser)	Determines whether the user with the given userName is allowed to update or delete the given query.
boolean	QueryStorage.canRead(IRI query, String currentUser)	Determines whether the user with the given userName is allowed to read the given query.
boolean	QueryStorage.checkAccess(HTTPRepository repository)	Checks whether the current user/password credentials can really access the current repository.
void	QueryStorage.deleteQuery(IRI query, String userName)	Delete the given query for the given user.
Resource	WorkbenchRequest.getResource(String name)	Returns a Resource corresponding to the value of the given parameter name.
static QueryStorage	QueryStorage.getSingletonInstance(AppConfiguration config)
IRI	WorkbenchRequest.getURI(String name)	Gets the URI referred to by the parameter value.
Value	WorkbenchRequest.getValue(String name)	Gets the Value referred to by the parameter value.
void	QueryStorage.selectSavedQueries(HTTPRepository repository, String userName, TupleResultBuilder builder)	Prepares a query to retrieve the queries accessible to the given user in the given repository.
void	QueryStorage.updateQuery(IRI query, String userName, boolean shared, QueryLanguage queryLanguage, String queryText, boolean infer, int rowsPerPage)	Update the entry for the given query.

Constructors in org.eclipse.rdf4j.workbench.util that throw RepositoryException

Modifier	Constructor	Description
	WorkbenchRequest(Repository repository, javax.servlet.http.HttpServletRequest request, Map<String,String> defaults)	Wrap a request with an object aware of the current repository and application defaults.

Uses of RepositoryException in org.eclipse.testsuite.rdf4j.sail.lucene

Methods in org.eclipse.testsuite.rdf4j.sail.lucene that throw RepositoryException

Modifier and Type	Method	Description
protected void	AbstractLuceneSailGeoSPARQLTest.checkPoints()
protected void	AbstractLuceneSailGeoSPARQLTest.checkPolygons()
void	AbstractLuceneSailGeoSPARQLTest.tearDown()
void	AbstractLuceneSailIndexedPropertiesTest.tearDown()
void	AbstractLuceneSailTest.tearDown()
void	AbstractLuceneSailGeoSPARQLTest.testComplexDistanceQuery()
void	AbstractLuceneSailGeoSPARQLTest.testComplexDistanceQueryMathExpr()
void	AbstractLuceneSailGeoSPARQLTest.testComplexIntersectionQuery()
void	AbstractLuceneSailTest.testComplexQueryOne()
void	AbstractLuceneSailTest.testComplexQueryTwo()
void	AbstractLuceneSailGeoSPARQLTest.testDistanceQuery()
void	AbstractLuceneSailTest.testFuzzyQuery()
void	AbstractLuceneSailTest.testGraphQuery()
void	AbstractLuceneSailGeoSPARQLTest.testIntersectionQuery()
void	AbstractLuceneSailTest.testMultipleLuceneQueries()
void	AbstractLuceneSailTest.testPredicateLuceneQueries()
void	AbstractLuceneSailTest.testPropertyVar()
void	AbstractLuceneSailTest.testQueryWithSpecifiedSubject()
void	AbstractLuceneSailIndexedPropertiesTest.testRegularQuery()
void	AbstractLuceneSailTest.testRegularQuery()
void	AbstractLuceneSailTest.testSnippetLimitedToPredicate()	Test if the snippets do not accidentially come from the "text" field while we actually expect them to come from the predicate field.
void	AbstractLuceneSailTest.testSnippetQueries()
void	AbstractLuceneSailTest.testUnionQuery()