org.eclipse.rdf4j.repository.base

## Class AbstractRepositoryConnection

- java.lang.Object
- - org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection

- All Implemented Interfaces:
    AutoCloseable, RepositoryConnection
  Direct Known Subclasses:
    RepositoryConnectionBase, RepositoryConnectionWrapper, SailRepositoryConnection, SPARQLConnection

      public abstract class AbstractRepositoryConnection
      extends Object
      implements RepositoryConnection

  Abstract class implementing most 'convenience' methods in the `RepositoryConnection` interface by transforming parameters and mapping the methods to the basic (abstractly declared) methods.

  Open connections are automatically closed when being garbage collected. A warning message will be logged when the system property `org.eclipse.rdf4j.repository.debug` has been set to a non-`null` value.

  Author:
    Jeen Broekstra, Arjohn Kampman

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected org.slf4j.Logger` | `logger`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `AbstractRepositoryConnection(Repository repository)`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `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, 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` | `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.
    `protected abstract void` | `addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `protected void` | `addWithoutCommit(Statement st, Resource... contexts)`
    `void` | `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` | `clear(Resource... contexts)` Removes all statements from a specific contexts in the repository.
    `void` | `close()` Closes the connection, freeing resources.
    `protected void` | `conditionalCommit(boolean condition)` Invokes `RepositoryConnection.commit()` if supplied boolean condition is `true`.
    `protected void` | `conditionalRollback(boolean condition)` Invokes `RepositoryConnection.rollback()` if supplied boolean condition is `true`.
    `void` | `export(RDFHandler handler, Resource... contexts)` Exports all explicit statements in the specified contexts to the supplied RDFHandler.
    `IsolationLevel` | `getIsolationLevel()` Retrieves the current `transaction isolation level` of the connection.
    `ParserConfig` | `getParserConfig()` Returns the parser configuration this connection uses for Rio-based operations.
    `Repository` | `getRepository()` Returns the Repository object to which this connection belongs.
    `ValueFactory` | `getValueFactory()` Gets a ValueFactory for this RepositoryConnection.
    `boolean` | `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` | `hasStatement(Statement st, boolean includeInferred, Resource... contexts)` Checks whether the repository contains the specified statement, optionally in the specified contexts.
    `boolean` | `isAutoCommit()` Deprecated. since 2.0. Use `RepositoryConnection.isActive()` instead.
    `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 queries that return `true` or `false`.
    `GraphQuery` | `prepareGraphQuery(QueryLanguage ql, String query)` Prepares queries that produce RDF graphs.
    `Query` | `prepareQuery(QueryLanguage ql, String query)` 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.
    `Update` | `prepareUpdate(QueryLanguage ql, String update)` Prepares an Update operation.
    `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, 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` | `remove(Statement st, Resource... contexts)` Removes the supplied statement from the specified contexts in the repository.
    `protected abstract void` | `removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `protected void` | `removeWithoutCommit(Statement st, Resource... contexts)`
    `void` | `setAutoCommit(boolean autoCommit)` Deprecated. since 2.0. Use `RepositoryConnection.begin()` instead.
    `void` | `setIsolationLevel(IsolationLevel level)` Sets the transaction isolation level for the next transaction(s) on this connection.
    `void` | `setParserConfig(ParserConfig parserConfig)` Set the parser configuration this connection should use for RDFParser-based operations.
    `protected boolean` | `startLocalTransaction()` Starts a new transaction if one is not already active.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.eclipse.rdf4j.repository.RepositoryConnection

      `add, add, begin, begin, clearNamespaces, commit, exportStatements, getContextIDs, getNamespace, getNamespaces, getStatements, getStatements, getStatements, hasStatement, isActive, prepareBooleanQuery, prepareBooleanQuery, prepareGraphQuery, prepareGraphQuery, prepareQuery, prepareQuery, prepareTupleQuery, prepareTupleQuery, prepareUpdate, prepareUpdate, remove, remove, removeNamespace, rollback, setNamespace, size`

- - ### Field Detail

    - #### logger

          protected final org.slf4j.Logger logger

  - ### Constructor Detail

    - #### AbstractRepositoryConnection

          protected AbstractRepositoryConnection(Repository repository)

  - ### Method Detail

    - #### setParserConfig

          public void setParserConfig(ParserConfig parserConfig)

      Description copied from interface: `RepositoryConnection`
      Set the parser configuration this connection should use for RDFParser-based operations.
      Specified by:
        `setParserConfig` in interface `RepositoryConnection`
      Parameters:
        `parserConfig` - a Rio RDF Parser configuration.

    - #### getParserConfig

          public ParserConfig getParserConfig()

      Description copied from interface: `RepositoryConnection`
      Returns the parser configuration this connection uses for Rio-based operations.
      Specified by:
        `getParserConfig` in interface `RepositoryConnection`
      Returns:
        a Rio RDF parser configuration.

    - #### getRepository

          public Repository getRepository()

      Description copied from interface: `RepositoryConnection`
      Returns the Repository object to which this connection belongs.
      Specified by:
        `getRepository` in interface `RepositoryConnection`

    - #### getValueFactory

          public ValueFactory getValueFactory()

      Description copied from interface: `RepositoryConnection`
      Gets a ValueFactory for this RepositoryConnection.
      Specified by:
        `getValueFactory` in interface `RepositoryConnection`
      Returns:
        A repository-specific ValueFactory.

    - #### begin

          public void begin(IsolationLevel level)
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Begins a new transaction with the supplied `IsolationLevel`, requiring `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` to be called to end the transaction.
      Specified by:
        `begin` in interface `RepositoryConnection`
      Parameters:
        `level` - The `IsolationLevel` at which this transaction will operate. If set to `null` the default isolation level of the underlying store will be used. If the specified isolation level is not supported by the underlying store, it will attempt to use a supported `compatible level` instead.
      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.
      See Also:
        `RepositoryConnection.begin()`, `RepositoryConnection.isActive()`, `RepositoryConnection.commit()`, `RepositoryConnection.rollback()`, `RepositoryConnection.setIsolationLevel(IsolationLevel)`

    - #### setIsolationLevel

          public void setIsolationLevel(IsolationLevel level)
                                 throws IllegalStateException

      Description copied from interface: `RepositoryConnection`
      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 `RepositoryConnection.begin()` will result in an exception.
      Specified by:
        `setIsolationLevel` in interface `RepositoryConnection`
      Parameters:
        `level` - the transaction isolation level to set.
      Throws:
        `IllegalStateException` - if the method is called while a transaction is already active.

    - #### getIsolationLevel

          public IsolationLevel getIsolationLevel()

      Description copied from interface: `RepositoryConnection`
      Retrieves the current `transaction isolation level` of the connection.
      Specified by:
        `getIsolationLevel` in interface `RepositoryConnection`
      Returns:
        the current transaction isolation level.

    - #### isOpen

          public boolean isOpen()
                         throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Checks whether this connection is open. A connection is open from the moment it is created until it is closed.
      Specified by:
        `isOpen` in interface `RepositoryConnection`
      Throws:
        `RepositoryException`
      See Also:
        `RepositoryConnection.close()`

    - #### close

          public void close()
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Closes the connection, freeing resources. If a `transaction` is `active` on the connection, all non-committed operations will be lost by actively calling `RepositoryConnection.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`
      Specified by:
        `close` in interface `RepositoryConnection`
      Throws:
        `RepositoryException` - If the connection could not be closed.

    - #### prepareQuery

          public Query prepareQuery(QueryLanguage ql,
                                    String query)
                             throws MalformedQueryException,
                                    RepositoryException

      Description copied from interface: `RepositoryConnection`
      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 `RepositoryConnection.prepareQuery(QueryLanguage, String, String)` instead.

      If you already know the type of query, using the more specific `RepositoryConnection.prepareTupleQuery(java.lang.String)`, `RepositoryConnection.prepareGraphQuery(java.lang.String)` or `RepositoryConnection.prepareBooleanQuery(java.lang.String)` is likely to be more efficient.

      Specified by:
        `prepareQuery` in interface `RepositoryConnection`
      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.
        `RepositoryException`

    - #### prepareTupleQuery

          public TupleQuery prepareTupleQuery(QueryLanguage ql,
                                              String query)
                                       throws MalformedQueryException,
                                              RepositoryException

      Description copied from interface: `RepositoryConnection`
      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 `RepositoryConnection.prepareTupleQuery(QueryLanguage, String, String)` instead.
      Specified by:
        `prepareTupleQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
      Returns:
        a `TupleQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepareGraphQuery

          public GraphQuery prepareGraphQuery(QueryLanguage ql,
                                              String query)
                                       throws MalformedQueryException,
                                              RepositoryException

      Description copied from interface: `RepositoryConnection`
      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 `RepositoryConnection.prepareGraphQuery(QueryLanguage, String, String)` instead.
      Specified by:
        `prepareGraphQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
      Returns:
        a `GraphQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepareBooleanQuery

          public BooleanQuery prepareBooleanQuery(QueryLanguage ql,
                                                  String query)
                                           throws MalformedQueryException,
                                                  RepositoryException

      Description copied from interface: `RepositoryConnection`
      Prepares queries that return `true` or `false`. In case the query contains relative URIs that need to be resolved against an external base URI, one should use `RepositoryConnection.prepareBooleanQuery(QueryLanguage, String, String)` instead.
      Specified by:
        `prepareBooleanQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
      Returns:
        a `BooleanQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepareUpdate

          public Update prepareUpdate(QueryLanguage ql,
                                      String update)
                               throws MalformedQueryException,
                                      RepositoryException

      Description copied from interface: `RepositoryConnection`
      Prepares an Update operation. In case the update string contains relative URIs that need to be resolved against an external base URI, one should use `RepositoryConnection.prepareUpdate(QueryLanguage, String, String)` instead.
      Specified by:
        `prepareUpdate` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the update operation is formulated.
        `update` - The update operation string.
      Returns:
        a `Update` ready to be executed on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied update operation string is malformed.
        `RepositoryException`

    - #### hasStatement

          public boolean hasStatement(Resource subj,
                                      IRI pred,
                                      Value obj,
                                      boolean includeInferred,
                                      Resource... contexts)
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
      Specified by:
        `hasStatement` in interface `RepositoryConnection`
      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.
        `includeInferred` - if false, no inferred statements are considered; if true, inferred statements are considered if available
        `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.
      Returns:
        true If a matching statement is in the repository in the specified context, false otherwise.
      Throws:
        `RepositoryException`

    - #### hasStatement

          public boolean hasStatement(Statement st,
                                      boolean includeInferred,
                                      Resource... contexts)
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Checks whether the repository contains the specified statement, optionally in the specified contexts.
      Specified by:
        `hasStatement` in interface `RepositoryConnection`
      Parameters:
        `st` - The statement to look for. Context information in the statement is ignored.
        `includeInferred` - if false, no inferred statements are considered; if true, inferred statements are considered if available
        `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:
        true If the repository contains the specified statement, false otherwise.
      Throws:
        `RepositoryException`

    - #### isEmpty

          public boolean isEmpty()
                          throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Returns `true` if this repository does not contain any (explicit) statements.
      Specified by:
        `isEmpty` in interface `RepositoryConnection`
      Returns:
        `true` if this repository is empty, `false` otherwise.
      Throws:
        `RepositoryException` - If the repository could not be checked to be empty.

    - #### export

          public void export(RDFHandler handler,
                             Resource... contexts)
                      throws RepositoryException,
                             RDFHandlerException

      Description copied from interface: `RepositoryConnection`
      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.
      Specified by:
        `export` in interface `RepositoryConnection`
      Parameters:
        `handler` - The handler that will handle the RDF data.
        `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.
      Throws:
        `RDFHandlerException` - If the handler encounters an unrecoverable error.
        `RepositoryException`

    - #### setAutoCommit

          @Deprecated
          public void setAutoCommit(boolean autoCommit)
                                         throws RepositoryException

      Deprecated. since 2.0. Use `RepositoryConnection.begin()` instead.
      Description copied from interface: `RepositoryConnection`
      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 `RepositoryConnection.commit()` or `RepositoryConnection.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.

      Specified by:
        `setAutoCommit` in interface `RepositoryConnection`
      Throws:
        `RepositoryException` - In case the mode switch failed, for example because a currently active transaction failed to commit.
      See Also:
        `RepositoryConnection.commit()`

    - #### isAutoCommit

          @Deprecated
          public boolean isAutoCommit()
                                           throws RepositoryException

      Deprecated. since 2.0. Use `RepositoryConnection.isActive()` instead.
      Description copied from interface: `RepositoryConnection`
      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. `RepositoryConnection.begin()` has not been called or;
      2. `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` have been called to finish the transaction.
      Specified by:
        `isAutoCommit` in interface `RepositoryConnection`
      Throws:
        `RepositoryException` - If a repository access error occurs.

    - #### add

          public void add(File file,
                          String baseURI,
                          RDFFormat dataFormat,
                          Resource... contexts)
                   throws IOException,
                          RDFParseException,
                          RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds RDF data from the specified file to a specific contexts in the repository.
      Specified by:
        `add` in interface `RepositoryConnection`
      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.
        `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

          public void add(URL url,
                          String baseURI,
                          RDFFormat dataFormat,
                          Resource... contexts)
                   throws IOException,
                          RDFParseException,
                          RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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. 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.
        `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

          public void add(InputStream in,
                          String baseURI,
                          RDFFormat dataFormat,
                          Resource... contexts)
                   throws IOException,
                          RDFParseException,
                          RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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.
        `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.

    - #### startLocalTransaction

          protected final boolean startLocalTransaction()
                                                 throws RepositoryException

      Starts a new transaction if one is not already active.
      Returns:
        `true` if a new transaction was started, `false` if a transaction was already active.
      Throws:
        `RepositoryException`

    - #### conditionalCommit

          protected final void conditionalCommit(boolean condition)
                                          throws RepositoryException

      Invokes `RepositoryConnection.commit()` if supplied boolean condition is `true`.
      Parameters:
        `condition` - a boolean condition.
      Throws:
        `RepositoryException`

    - #### conditionalRollback

          protected final void conditionalRollback(boolean condition)
                                            throws RepositoryException

      Invokes `RepositoryConnection.rollback()` if supplied boolean condition is `true`.
      Parameters:
        `condition` - a boolean condition.
      Throws:
        `RepositoryException`

    - #### add

          public void add(Reader reader,
                          String baseURI,
                          RDFFormat dataFormat,
                          Resource... contexts)
                   throws IOException,
                          RDFParseException,
                          RepositoryException

      Description copied from interface: `RepositoryConnection`
      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.
      Specified by:
        `add` in interface `RepositoryConnection`
      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.
        `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

          public void add(Iterable<? extends Statement> statements,
                          Resource... contexts)
                   throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds the supplied statements to this repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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

          public <E extends Exception> void add(Iteration<? extends Statement,E> statements,
                                                Resource... contexts)
                                         throws RepositoryException,
                                                E extends Exception

      Description copied from interface: `RepositoryConnection`
      Adds the supplied statements to this repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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

          public void add(Statement st,
                          Resource... contexts)
                   throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds the supplied statement to this repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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

          public void add(Resource subject,
                          IRI predicate,
                          Value object,
                          Resource... contexts)
                   throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
      Specified by:
        `add` in interface `RepositoryConnection`
      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.

    - #### remove

          public void remove(Iterable<? extends Statement> statements,
                             Resource... contexts)
                      throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes the supplied statements from the specified contexts in this repository.
      Specified by:
        `remove` in interface `RepositoryConnection`
      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

          public <E extends Exception> void remove(Iteration<? extends Statement,E> statements,
                                                   Resource... contexts)
                                            throws RepositoryException,
                                                   E extends Exception

      Description copied from interface: `RepositoryConnection`
      Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
      Specified by:
        `remove` in interface `RepositoryConnection`
      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

          public void remove(Statement st,
                             Resource... contexts)
                      throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes the supplied statement from the specified contexts in the repository.
      Specified by:
        `remove` in interface `RepositoryConnection`
      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

          public void remove(Resource subject,
                             IRI predicate,
                             Value object,
                             Resource... contexts)
                      throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
      Specified by:
        `remove` in interface `RepositoryConnection`
      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.

    - #### clear

          public void clear(Resource... contexts)
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes all statements from a specific contexts in the repository.
      Specified by:
        `clear` in interface `RepositoryConnection`
      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.

    - #### addWithoutCommit

          protected void addWithoutCommit(Statement st,
                                          Resource... contexts)
                                   throws RepositoryException

      Throws:
        `RepositoryException`

    - #### addWithoutCommit

          protected abstract void addWithoutCommit(Resource subject,
                                                   IRI predicate,
                                                   Value object,
                                                   Resource... contexts)
                                            throws RepositoryException

      Throws:
        `RepositoryException`

    - #### removeWithoutCommit

          protected void removeWithoutCommit(Statement st,
                                             Resource... contexts)
                                      throws RepositoryException

      Throws:
        `RepositoryException`

    - #### removeWithoutCommit

          protected abstract void removeWithoutCommit(Resource subject,
                                                      IRI predicate,
                                                      Value object,
                                                      Resource... contexts)
                                               throws RepositoryException

      Throws:
        `RepositoryException`

Copyright © 2015-2020 Eclipse Foundation. All Rights Reserved.