Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

org.openrdf.repository
Interface RepositoryConnection

All Known Subinterfaces:
DelegatingRepositoryConnection, InterceptingRepositoryConnection, NotifyingRepositoryConnection
All Known Implementing Classes:
ContextAwareConnection, DatasetRepositoryConnection, InterceptingRepositoryConnectionWrapper, NotifyingRepositoryConnectionWrapper, RepositoryConnectionBase, RepositoryConnectionWrapper, SailRepositoryConnection
public interface RepositoryConnection

Main interface for updating data in and performing queries on a Sesame repository. By default, a RepositoryConnection is in autoCommit mode, meaning that each operation corresponds to a single transaction on the underlying store. autoCommit can be switched off in which case it is up to the user to handle transaction commit/rollback. Note that care should be taking to always properly close a RepositoryConnection after one is finished with it, to free up resources and avoid unnecessary locks.

Several methods take a vararg argument that optionally specifies a (set of) context(s) on which the method should operate. Note that a vararg parameter is optional, it can be completely left out of the method call, in which case a method either operates on a provided statements context (if one of the method parameters is a statement or collection of statements), or operates on the repository as a whole, completely ignoring context. A vararg argument may also be 'null' (cast to Resource) meaning that the method operates on those statements which have no associated context only.

Examples: 

 // Ex 1: this method retrieves all statements that appear in either context1 or context2, or both.
 RepositoryConnection.getStatements(null, null, null, true, context1, context2);
 
 // Ex 2: this method retrieves all statements that appear in the repository (regardless of context).
 RepositoryConnection.getStatements(null, null, null, true);
 
 // Ex 3: this method retrieves all statements that have no associated context in the repository.
 // Observe that this is not equivalent to the previous method call.
 RepositoryConnection.getStatements(null, null, null, true, (Resource)null);
 
 // Ex 4: this method adds a statement to the store. If the statement object itself has 
 // a context (i.e. statement.getContext() != null) the statement is added to that context. Otherwise,
 // it is added without any associated context.
 RepositoryConnection.add(statement);
 
 // Ex 5: this method adds a statement to context1 in the store. It completely ignores any
 // context the statement itself has.
 RepositoryConnection.add(statement, context1);

Author:
Arjohn Kampman, jeen

Method Summary
 void add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)
          Adds RDF data from the specified file to a specific contexts in the repository.
 void 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.
 void add(Iterable<? extends Statement> statements, Resource... contexts)
          Adds the supplied statements to this repository, optionally to one or more named contexts.
<E extends Exception>
void
add(Iteration<? extends Statement,E> statements, Resource... contexts)
          Adds the supplied statements to this repository, optionally to one or more named contexts.
 void 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.
 void add(Resource subject, URI 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 add(Statement st, Resource... contexts)
          Adds the supplied statement to this repository, optionally to one or more named contexts.
 void 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.
 void clear(Resource... contexts)
          Removes all statements from a specific contexts in the repository.
 void clearNamespaces()
          Removes all namespace declarations from the repository.
 void close()
          Closes the connection, freeing resources.
 void commit()
          Commits all updates that have been performed as part of this connection sofar.
 void export(RDFHandler handler, Resource... contexts)
          Exports all explicit statements in the specified contexts to the supplied RDFHandler.
 void exportStatements(Resource subj, URI 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.
 RepositoryResult<Resource> getContextIDs()
          Gets all resources that are used as content identifiers.
 String getNamespace(String prefix)
          Gets the namespace that is associated with the specified prefix, if any.
 RepositoryResult<Namespace> getNamespaces()
          Gets all declared namespaces as a RepositoryResult of Namespace objects.
 Repository getRepository()
          Returns the Repository object to which this connection belongs.
 RepositoryResult<Statement> getStatements(Resource subj, URI pred, Value obj, boolean includeInferred, Resource... contexts)
          Gets all statements with a specific subject, predicate and/or object from the repository.
 ValueFactory getValueFactory()
          Gets a ValueFactory for this RepositoryConnection.
 boolean hasStatement(Resource subj, URI 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 hasStatement(Statement st, boolean includeInferred, Resource... contexts)
          Checks whether the repository contains the specified statement, optionally in the specified contexts.
 boolean isAutoCommit()
          Checks whether the connection is in auto-commit mode.
 boolean isEmpty()
          Returns true if this repository does not contain any (explicit) statements.
 boolean isOpen()
          Checks whether this connection is open.
 BooleanQuery prepareBooleanQuery(QueryLanguage ql, String query)
          Prepares true/false queries.
 BooleanQuery prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)
          Prepares true/false queries.
 GraphQuery prepareGraphQuery(QueryLanguage ql, String query)
          Prepares queries that produce RDF graphs.
 GraphQuery prepareGraphQuery(QueryLanguage ql, String query, String baseURI)
          Prepares queries that produce RDF graphs.
 Query prepareQuery(QueryLanguage ql, String query)
          Prepares a query for evaluation on this repository (optional operation).
 Query prepareQuery(QueryLanguage ql, String query, String baseURI)
          Prepares a query for evaluation on this repository (optional operation).
 TupleQuery prepareTupleQuery(QueryLanguage ql, String query)
          Prepares a query that produces sets of value tuples.
 TupleQuery prepareTupleQuery(QueryLanguage ql, String query, String baseURI)
          Prepares a query that produces sets of value tuples.
 void remove(Iterable<? extends Statement> statements, Resource... contexts)
          Removes the supplied statements from the specified contexts in this repository.
<E extends Exception>
void
remove(Iteration<? extends Statement,E> statements, Resource... contexts)
          Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
 void remove(Resource subject, URI 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 remove(Statement st, Resource... contexts)
          Removes the supplied statement from the specified contexts in the repository.
 void removeNamespace(String prefix)
          Removes a namespace declaration by removing the association between a prefix and a namespace name.
 void rollback()
          Rolls back all updates that have been performed as part of this connection sofar.
 void setAutoCommit(boolean autoCommit)
          Enables or disables auto-commit mode for the connection.
 void setNamespace(String prefix, String name)
          Sets the prefix for a namespace.
 long size(Resource... contexts)
          Returns the number of (explicit) statements that are in the specified contexts in this repository.
 

Method Detail

getRepository

Repository getRepository()
Returns the Repository object to which this connection belongs.

getValueFactory

ValueFactory getValueFactory()
Gets a ValueFactory for this RepositoryConnection.

Returns:
A repository-specific ValueFactory.

isOpen

boolean isOpen()
               throws RepositoryException
Checks whether this connection is open. A connection is open from the moment it is created until it is closed.

Throws:
RepositoryException
See Also:
close()

close

void close()
           throws RepositoryException
Closes the connection, freeing resources. If the connection is not in autoCommit mode, all non-committed operations will be lost.

Throws:
RepositoryException - If the connection could not be closed.

prepareQuery

Query prepareQuery(QueryLanguage ql,
                   String query)
                   throws RepositoryException,
                          MalformedQueryException
Prepares a query for evaluation on this repository (optional operation). In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareQuery(QueryLanguage, String, String) instead.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
Returns:
A query ready to be evaluated on this repository.
Throws:
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
UnsupportedOperationException - If the prepareQuery method is not supported by this repository.
RepositoryException

prepareQuery

Query prepareQuery(QueryLanguage ql,
                   String query,
                   String baseURI)
                   throws RepositoryException,
                          MalformedQueryException
Prepares a query for evaluation on this repository (optional operation).

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.
Returns:
A query ready to be evaluated on this repository.
Throws:
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
UnsupportedOperationException - If the prepareQuery method is not supported by this repository.
RepositoryException

prepareTupleQuery

TupleQuery prepareTupleQuery(QueryLanguage ql,
                             String query)
                             throws RepositoryException,
                                    MalformedQueryException
Prepares a query that produces sets of value tuples. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareTupleQuery(QueryLanguage, String, String) instead.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
Throws:
IllegalArgumentException - If the supplied query is not a tuple query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

prepareTupleQuery

TupleQuery prepareTupleQuery(QueryLanguage ql,
                             String query,
                             String baseURI)
                             throws RepositoryException,
                                    MalformedQueryException
Prepares a query that produces sets of value tuples.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.
Throws:
IllegalArgumentException - If the supplied query is not a tuple query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

prepareGraphQuery

GraphQuery prepareGraphQuery(QueryLanguage ql,
                             String query)
                             throws RepositoryException,
                                    MalformedQueryException
Prepares queries that produce RDF graphs. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareGraphQuery(QueryLanguage, String, String) instead.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
Throws:
IllegalArgumentException - If the supplied query is not a graph query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

prepareGraphQuery

GraphQuery prepareGraphQuery(QueryLanguage ql,
                             String query,
                             String baseURI)
                             throws RepositoryException,
                                    MalformedQueryException
Prepares queries that produce RDF graphs.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.
Throws:
IllegalArgumentException - If the supplied query is not a graph query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

prepareBooleanQuery

BooleanQuery prepareBooleanQuery(QueryLanguage ql,
                                 String query)
                                 throws RepositoryException,
                                        MalformedQueryException
Prepares true/false queries. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareBooleanQuery(QueryLanguage, String, String) instead.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
Throws:
IllegalArgumentException - If the supplied query is not a boolean query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

prepareBooleanQuery

BooleanQuery prepareBooleanQuery(QueryLanguage ql,
                                 String query,
                                 String baseURI)
                                 throws RepositoryException,
                                        MalformedQueryException
Prepares true/false queries.

Parameters:
ql - The query language in which the query is formulated.
query - The query string.
baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.
Throws:
IllegalArgumentException - If the supplied query is not a boolean query.
MalformedQueryException - If the supplied query is malformed.
UnsupportedQueryLanguageException - If the supplied query language is not supported.
RepositoryException

getContextIDs

RepositoryResult<Resource> getContextIDs()
                                         throws RepositoryException
Gets all resources that are used as content identifiers. Care should be taken that the returned RepositoryResult is closed to free any resources that it keeps hold of.

Returns:
a RepositoryResult object containing Resources that are used as context identifiers.
Throws:
RepositoryException

getStatements

RepositoryResult<Statement> getStatements(Resource subj,
                                          URI pred,
                                          Value obj,
                                          boolean includeInferred,
                                          Resource... contexts)
                                          throws RepositoryException
Gets all statements with a specific subject, predicate and/or object from the repository. The result is optionally restricted to the specified set of named contexts.

Parameters:
subj - A Resource specifying the subject, or null for a wildcard.
pred - A URI specifying the predicate, or null for a wildcard.
obj - A Value specifying the object, or null for a wildcard.
contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
includeInferred - if false, no inferred statements are returned; if true, inferred statements are returned if available. The default is true.
Returns:
The statements matching the specified pattern. The result object is a RepositoryResult object, a lazy Iterator-like object containing Statements and optionally throwing a RepositoryException when an error when a problem occurs during retrieval.
Throws:
RepositoryException

hasStatement

boolean hasStatement(Resource subj,
                     URI pred,
                     Value obj,
                     boolean includeInferred,
                     Resource... contexts)
                     throws RepositoryException
Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.

Parameters:
subj - A Resource specifying the subject, or null for a wildcard.
pred - A URI specifying the predicate, or null for a wildcard.
obj - A Value specifying the object, or null for a wildcard.
contexts - The context(s) the need to be searched. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
includeInferred - if false, no inferred statements are considered; if true, inferred statements are considered if available
Returns:
true If a matching statement is in the repository in the specified context, false otherwise.
Throws:
RepositoryException

hasStatement

boolean hasStatement(Statement st,
                     boolean includeInferred,
                     Resource... contexts)
                     throws RepositoryException
Checks whether the repository contains the specified statement, optionally in the specified contexts.

Parameters:
st - The statement to look for. Context information in the statement is ignored.
contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
includeInferred - if false, no inferred statements are considered; if true, inferred statements are considered if available
Returns:
true If the repository contains the specified statement, false otherwise.
Throws:
RepositoryException

exportStatements

void exportStatements(Resource subj,
                      URI pred,
                      Value obj,
                      boolean includeInferred,
                      RDFHandler handler,
                      Resource... contexts)
                      throws RepositoryException,
                             RDFHandlerException
Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.

Parameters:
subj - The subject, or null if the subject doesn't matter.
pred - The predicate, or null if the predicate doesn't matter.
obj - The object, or null if the object doesn't matter.
contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
handler - The handler that will handle the RDF data.
includeInferred - if false, no inferred statements are returned; if true, inferred statements are returned if available
Throws:
RDFHandlerException - If the handler encounters an unrecoverable error.
RepositoryException

export

void export(RDFHandler handler,
            Resource... contexts)
            throws RepositoryException,
                   RDFHandlerException
Exports all explicit statements in the specified contexts to the supplied RDFHandler.

Parameters:
contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
handler - The handler that will handle the RDF data.
Throws:
RDFHandlerException - If the handler encounters an unrecoverable error.
RepositoryException

size

long size(Resource... contexts)
          throws RepositoryException
Returns the number of (explicit) statements that are in the specified contexts in this repository.

Parameters:
contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
Returns:
The number of explicit statements from the specified contexts in this repository.
Throws:
RepositoryException

isEmpty

boolean isEmpty()
                throws RepositoryException
Returns true if this repository does not contain any (explicit) statements.

Returns:
true if this repository is empty, false otherwise.
Throws:
RepositoryException - If the repository could not be checked to be empty.

setAutoCommit

void setAutoCommit(boolean autoCommit)
                   throws RepositoryException
Enables or disables auto-commit mode for the connection. If a connection is in auto-commit mode, then all updates will be executed and committed as individual transactions. Otherwise, the updates are grouped into transactions that are terminated by a call to either commit() or rollback(). By default, new connections are in auto-commit mode.

NOTE: If this connection is switched to auto-commit mode during a transaction, the transaction is committed.

Throws:
RepositoryException - In case the mode switch failed, for example because a currently active transaction failed to commit.
See Also:
commit()

isAutoCommit

boolean isAutoCommit()
                     throws RepositoryException
Checks whether the connection is in auto-commit mode.

Throws:
RepositoryException
See Also:
setAutoCommit(boolean)

commit

void commit()
            throws RepositoryException
Commits all updates that have been performed as part of this connection sofar.

Throws:
RepositoryException - If the connection could not be committed.

rollback

void rollback()
              throws RepositoryException
Rolls back all updates that have been performed as part of this connection sofar.

Throws:
RepositoryException - If the connection could not be rolled back.

add

void add(InputStream in,
         String baseURI,
         RDFFormat dataFormat,
         Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.

Parameters:
in - An InputStream from which RDF data can be read.
baseURI - The base URI to resolve any relative URIs that are in the data against.
dataFormat - The serialization format of the data.
contexts - The contexts to add the data to. If one or more contexts are supplied the method ignores contextual information in the actual data. If no contexts are supplied the contextual information in the input stream is used, if no context information is available the data is added without any context.
Throws:
IOException - If an I/O error occurred while reading from the input stream.
UnsupportedRDFormatException - If no parser is available for the specified RDF format.
RDFParseException - If an error was found while parsing the RDF data.
RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

void add(Reader reader,
         String baseURI,
         RDFFormat dataFormat,
         Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
Adds RDF data from a Reader to the repository, optionally to one or more named contexts. Note: using a Reader to upload byte-based data means that you have to be careful not to destroy the data's character encoding by enforcing a default character encoding upon the bytes. If possible, adding such data using an InputStream is to be preferred.

Parameters:
reader - A Reader from which RDF data can be read.
baseURI - The base URI to resolve any relative URIs that are in the data against.
dataFormat - The serialization format of the data.
contexts - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
Throws:
IOException - If an I/O error occurred while reading from the reader.
UnsupportedRDFormatException - If no parser is available for the specified RDF format.
RDFParseException - If an error was found while parsing the RDF data.
RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

void add(URL url,
         String baseURI,
         RDFFormat dataFormat,
         Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.

Parameters:
url - The URL of the RDF data.
baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of url.toExternalForm() if the value is set to null.
dataFormat - The serialization format of the data.
contexts - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
Throws:
IOException - If an I/O error occurred while reading from the URL.
UnsupportedRDFormatException - If no parser is available for the specified RDF format.
RDFParseException - If an error was found while parsing the RDF data.
RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

void add(File file,
         String baseURI,
         RDFFormat dataFormat,
         Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
Adds RDF data from the specified file to a specific contexts in the repository.

Parameters:
file - A file containing RDF data.
baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of file.toURI() if the value is set to null.
dataFormat - The serialization format of the data.
contexts - The contexts to add the data to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the data is added to any context specified in the actual data file, or if the data contains no context, it is added without context. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
Throws:
IOException - If an I/O error occurred while reading from the file.
UnsupportedRDFormatException - If no parser is available for the specified RDF format.
RDFParseException - If an error was found while parsing the RDF data.
RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

void add(Resource subject,
         URI predicate,
         Value object,
         Resource... contexts)
         throws RepositoryException
Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.

Parameters:
subject - The statement's subject.
predicate - The statement's predicate.
object - The statement's object.
contexts - The contexts to add the data to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the data is added to any context specified in the actual data file, or if the data contains no context, it is added without context. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
Throws:
RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

void add(Statement st,
         Resource... contexts)
         throws RepositoryException
Adds the supplied statement to this repository, optionally to one or more named contexts.

Parameters:
st - The statement to add.
contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the statement is added to any context specified in each statement, or if the statement contains no context, it is added without context. If one or more contexts are specified the statement is added to these contexts, ignoring any context information in the statement itself.
Throws:
RepositoryException - If the statement could not be added to the repository, for example because the repository is not writable.

add

void add(Iterable<? extends Statement> statements,
         Resource... contexts)
         throws RepositoryException
Adds the supplied statements to this repository, optionally to one or more named contexts.

Parameters:
statements - The statements that should be added.
contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, each statement is added to any context specified in the statement, or if the statement contains no context, it is added without context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself. ignored.
Throws:
RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.

add

<E extends Exception> void add(Iteration<? extends Statement,E> statements,
                               Resource... contexts)
         throws RepositoryException,
                E extends Exception
Adds the supplied statements to this repository, optionally to one or more named contexts.

Parameters:
statements - The statements to add. In case the iteration is a CloseableIteration, it will be closed before this method returns.
contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, each statement is added to any context specified in the statement, or if the statement contains no context, it is added without context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself. ignored.
Throws:
RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
E extends Exception

remove

void remove(Resource subject,
            URI predicate,
            Value object,
            Resource... contexts)
            throws RepositoryException
Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.

Parameters:
subject - The statement's subject, or null for a wildcard.
predicate - The statement's predicate, or null for a wildcard.
object - The statement's object, or null for a wildcard.
contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
Throws:
RepositoryException - If the statement(s) could not be removed from the repository, for example because the repository is not writable.

remove

void remove(Statement st,
            Resource... contexts)
            throws RepositoryException
Removes the supplied statement from the specified contexts in the repository.

Parameters:
st - The statement to remove.
contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
Throws:
RepositoryException - If the statement could not be removed from the repository, for example because the repository is not writable.

remove

void remove(Iterable<? extends Statement> statements,
            Resource... contexts)
            throws RepositoryException
Removes the supplied statements from the specified contexts in this repository.

Parameters:
statements - The statements that should be added.
contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
Throws:
RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.

remove

<E extends Exception> void remove(Iteration<? extends Statement,E> statements,
                                  Resource... contexts)
            throws RepositoryException,
                   E extends Exception
Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.

Parameters:
statements - The statements to remove. In case the iteration is a CloseableIteration, it will be closed before this method returns.
contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
Throws:
RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.
E extends Exception

clear

void clear(Resource... contexts)
           throws RepositoryException
Removes all statements from a specific contexts in the repository.

Parameters:
contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
Throws:
RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.

getNamespaces

RepositoryResult<Namespace> getNamespaces()
                                          throws RepositoryException
Gets all declared namespaces as a RepositoryResult of Namespace objects. Each Namespace object consists of a prefix and a namespace name.

Returns:
A RepositoryResult containing Namespace objects. Care should be taken to close the RepositoryResult after use.
Throws:
RepositoryException - If the namespaces could not be read from the repository.

getNamespace

String getNamespace(String prefix)
                    throws RepositoryException
Gets the namespace that is associated with the specified prefix, if any.

Parameters:
prefix - A namespace prefix.
Returns:
The namespace name that is associated with the specified prefix, or null if there is no such namespace.
Throws:
RepositoryException - If the namespace could not be read from the repository.

setNamespace

void setNamespace(String prefix,
                  String name)
                  throws RepositoryException
Sets the prefix for a namespace.

Parameters:
prefix - The new prefix.
name - The namespace name that the prefix maps to.
Throws:
RepositoryException - If the namespace could not be set in the repository, for example because the repository is not writable.

removeNamespace

void removeNamespace(String prefix)
                     throws RepositoryException
Removes a namespace declaration by removing the association between a prefix and a namespace name.

Parameters:
prefix - The namespace prefix of which the assocation with a namespace name is to be removed.
Throws:
RepositoryException - If the namespace prefix could not be removed.

clearNamespaces

void clearNamespaces()
                     throws RepositoryException
Removes all namespace declarations from the repository.

Throws:
RepositoryException - If the namespace declarations could not be removed.
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Copyright © 2001-2010 Aduna. All Rights Reserved.