Package org.eclipse.rdf4j.repository

Interface RepositoryConnection

  • All Superinterfaces:
    AutoCloseable
    All Known Subinterfaces:
    DelegatingRepositoryConnection, InterceptingRepositoryConnection, NotifyingRepositoryConnection
    All Known Implementing Classes:
    AbstractRepositoryConnection, CachingRepositoryConnection, ContextAwareConnection, DatasetRepositoryConnection, EndpointBase.ManagedRepositoryConnection, FedXRepositoryConnection, InterceptingRepositoryConnectionWrapper, LoggingRepositoryConnection, NotifyingRepositoryConnectionWrapper, PooledRepositoryConnection, RepositoryConnectionWrapper, SailRepositoryConnection, SPARQLConnection, TransactionalRepositoryConnection
    public interface RepositoryConnection
extends AutoCloseable
    Main interface for updating data in and performing queries on an RDF4J Repository.

    By default, a RepositoryConnection is in auto-commit mode, meaning that each operation corresponds to a single transaction on the underlying store. Multiple operations can be bundled in a single transaction by using begin() and commit/ rollback, which may improve performance considerably when dealing with many thousands of statements. Care should be taking to always properly close a RepositoryConnection after one is finished with it, to free up resources and avoid unnecessary locks.

    RepositoryConnection is not guaranteed to be thread-safe. The recommended access pattern in a multithreaded application is to ensure that each thread creates/uses its own RepositoryConnections (which can be obtained from a shared Repository).

    Several methods take a vararg argument that optionally specifies one or more contexts (named graphs) on which the method should operate. 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 Broekstra
    See Also:
    Repositories

    • Method Detail

      • getRepository

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

      • setParserConfig

        void setParserConfig​(ParserConfig config)
        Set the parser configuration this connection should use for RDFParser-based operations.
        Parameters:
        config - a Rio RDF Parser configuration.

      • getParserConfig

        ParserConfig getParserConfig()
        Returns the parser configuration this connection uses for Rio-based operations.
        Returns:
        a Rio RDF parser configuration.

      • getValueFactory

        ValueFactory getValueFactory()
        Gets a ValueFactory for this RepositoryConnection.
        Returns:
        A repository-specific ValueFactory.

      • close

        default void close()
            throws RepositoryException
        Closes the connection, freeing resources. If a transaction is active on the connection, all non-committed operations will be lost by actively calling rollback() on any active transactions.

        Implementation note: All implementations must override this method if they have any resources that they need to free.

        Specified by:
        close in interface AutoCloseable
        Throws:
        RepositoryException - If the connection could not be closed.

      • getStatements

        default RepositoryResult<Statement> getStatements​(Resource subj,
                                                  IRI pred,
                                                  Value obj,
                                                  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. If the repository supports inferencing, inferred statements will be included in the result.
        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.
        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

      • getStatements

        RepositoryResult<Statement> getStatements​(Resource subj,
                                          IRI 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 - An IRI 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,
                     IRI 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 - An IRI 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,
                      IRI 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. This method supplies the RDFHandler with all namespace declarations available in the repository.
        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. This method supplies the RDFHandler with all namespace declarations available in the 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.
        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

        @Deprecated
void setAutoCommit​(boolean autoCommit)
            throws RepositoryException
        Deprecated.
        As of release 2.7.0, use begin() instead.
        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

        @Deprecated
boolean isAutoCommit()
              throws RepositoryException
        Deprecated.
        since 2.0. Use isActive() instead.
        Indicates if the connection is in auto-commit mode. The connection is in auto-commit mode when no transaction is currently active, that is, when:
        1. begin() has not been called or;
        2. commit() or rollback() have been called to finish the transaction.
        Throws:
        RepositoryException - If a repository access error occurs.

      • setIsolationLevel

        void setIsolationLevel​(IsolationLevel level)
                throws IllegalStateException
        Sets the transaction isolation level for the next transaction(s) on this connection. If the level is set to a value that is not supported by the underlying repository, this method will still succeed but a subsequent call to begin() will result in an exception.
        Parameters:
        level - the transaction isolation level to set.
        Throws:
        IllegalStateException - if the method is called while a transaction is already active.

      • begin

        default void begin​(TransactionSetting... settings)
        Begins a new transaction with the supplied TransactionSetting, requiring commit() or rollback() to be called to end the transaction.
        Parameters:
        settings - The TransactionSetting (zero or more) for this transaction. If an isolation level is provided in the settings this will be used for the transaction. If none is provided then the default will be used. Behaviour of this method is undefined if more than one isolation level is provided. Behaviour of this method is undefined if one or more settings is null.
        Throws:
        RepositoryException - If the connection could not start the transaction. Possible reasons this may happen are:
        • a transaction is already active on the current connection.
        • the specified IsolationLevel is not supported by the store, and no compatible level could be found.
        Since:
        3.3.0
        See Also:
        begin(), isActive(), commit(), rollback(), setIsolationLevel(IsolationLevel)

      • prepare

        default void prepare()
              throws RepositoryException
        Checks for an error state in the active transaction that would force the transaction to be rolled back. This is an optional call; calling or not calling this method should have no effect on the outcome of commit() or rollback(). A call to this method must be followed by (in the same thread) with a call to prepare() , commit(), rollback(), or close() . This method may be called multiple times within the same transaction by the same thread. If this method returns normally, the caller can reasonably expect that a subsequent call to commit() will also return normally. If this method returns with an exception the caller should treat the exception as if it came from a call to commit().
        Throws:
        UnknownTransactionStateException - If the transaction state can not be determined (this can happen for instance when communication between client and server fails or times-out). It does not indicate a problem with the integrity of the store.
        RepositoryException - If there is an active transaction and it cannot be committed.
        IllegalStateException - If the connection has been closed or prepare was already called by another thread.
        Since:
        3.5.0
        See Also:
        commit(), begin(), rollback()

      • rollback

        void rollback()
       throws RepositoryException
        Rolls back all updates in the active transaction. This operation ends the active transaction.
        Throws:
        UnknownTransactionStateException - if the transaction state can not be determined. This can happen for instance when communication with a repository fails or times out.
        RepositoryException - If the transaction could not be rolled back, or if the connection does not have an active transaction.
        See Also:
        isActive(), begin(), commit()

      • add

        default void add​(InputStream in,
                 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.
        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.
        Since:
        3.5.0

      • 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. May be null.

        Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).

        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

        default void add​(Reader reader,
                 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.
        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.
        Since:
        3.5.0

      • 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. May be null.

        Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).

        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

        default void add​(URL url,
                 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.
        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 the RDF format could not be recognized.
        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.
        Since:
        3.5.0

      • add

        default void add​(URL url,
                 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.
        dataFormat - The serialization format of the data. If set to null, the format will be automatically determined by examining the content type in the HTTP response header, and failing that, the file name extension of the supplied URL.
        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, or the RDF format could not be automatically determined.
        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.
        Since:
        3.5.0

      • 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.

        Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).

        dataFormat - The serialization format of the data. If set to null, the format will be automatically determined by examining the content type in the HTTP response header, and failing that, the file name extension of the supplied URL.
        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, or the RDF format could not be automatically determined.
        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

        default void add​(File file,
                 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.
        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 the RDF format of the supplied file could not be recognized.
        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.
        Since:
        3.5.0

      • add

        default void add​(File file,
                 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.
        dataFormat - The serialization format of the data. If set to null, the format will be automatically determined by examining the file name extension of the supplied File.
        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.
        Since:
        3.5.0

      • 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.

        Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).

        dataFormat - The serialization format of the data. If set to null, the format will be automatically determined by examining the file name extension of the supplied File.
        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,
         IRI 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. In case the iterable is NamespaceAware and the target repository supports it, the iterable's namespaces are also added to the repository, without overwriting existing ones.
        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

        @Deprecated(since="4.1.0",
            forRemoval=true)
<E extends Exception> void add​(Iteration<? extends Statement,​E> statements,
                               Resource... contexts)
                        throws RepositoryException,
                               E extends Exception
        Deprecated, for removal: This API element is subject to removal in a future version.
        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

      • add

        default <E extends Exception> void add​(CloseableIteration<? 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. The iteration will be closed.
        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

      • add

        default void add​(RepositoryResult<Statement> statements,
                 Resource... contexts)
          throws RepositoryException
        Adds the supplied statements to this repository, optionally to one or more named contexts.
        Parameters:
        statements - The statements to add. The @{link RepositoryResult} 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.

      • remove

        void remove​(Resource subject,
            IRI 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

        @Deprecated(since="4.1.0",
            forRemoval=true)
<E extends Exception> void remove​(Iteration<? extends Statement,​E> statements,
                                  Resource... contexts)
                           throws RepositoryException,
                                  E extends Exception
        Deprecated, for removal: This API element is subject to removal in a future version.
        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

      • remove

        default <E extends Exception> void remove​(CloseableIteration<? 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. The iteration will be closed.
        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

      • remove

        default void remove​(RepositoryResult<Statement> statements,
                    Resource... contexts)
             throws RepositoryException
        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. The RepositoryResult 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.

      • 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, or an empty string in case of the default namespace.
        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.
        NullPointerException - In case prefix is null.

      • setNamespace

        void setNamespace​(String prefix,
                  String name)
           throws RepositoryException
        Sets the prefix for a namespace.
        Parameters:
        prefix - The new prefix, or an empty string in case of the default namespace.
        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.
        NullPointerException - In case prefix or name is null.

      • 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, or an empty string in case of the default namespace.
        Throws:
        RepositoryException - If the namespace prefix could not be removed.
        NullPointerException - In case prefix is null.

      • clearNamespaces

        void clearNamespaces()
              throws RepositoryException
        Removes all namespace declarations from the repository.
        Throws:
        RepositoryException - If the namespace declarations could not be removed.