org.eclipse.rdf4j.repository

## Interface RepositoryConnection

- All Superinterfaces:
    AutoCloseable
  All Known Subinterfaces:
    DelegatingRepositoryConnection, InterceptingRepositoryConnection, NotifyingRepositoryConnection
  All Known Implementing Classes:
    AbstractRepositoryConnection, ContextAwareConnection, DatasetRepositoryConnection, InterceptingRepositoryConnectionWrapper, NotifyingRepositoryConnectionWrapper, RepositoryConnectionBase, RepositoryConnectionWrapper, SailRepositoryConnection, SPARQLConnection

      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`. 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 Summary

    All Methods Instance Methods Abstract Methods Default 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.
    `default void` | `add(Resource subject, URI predicate, Value object, Resource... contexts)` Deprecated. since 2.0. Use `add(Resource, IRI, Value, Resource...)` instead.
    `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` | `begin()` Begins a new transaction, requiring `commit()` or `rollback()` to be called to end the transaction.
    `void` | `begin(IsolationLevel level)` Begins a new transaction with the supplied `IsolationLevel`, requiring `commit()` or `rollback()` to be called to end the transaction.
    `void` | `clear(Resource... contexts)` Removes all statements from a specific contexts in the repository.
    `void` | `clearNamespaces()` Removes all namespace declarations from the repository.
    `default void` | `close()` Closes the connection, freeing resources.
    `void` | `commit()` Commits the active transaction.
    `void` | `export(RDFHandler handler, Resource... contexts)` Exports all explicit statements in the specified contexts to the supplied RDFHandler.
    `void` | `exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts)` Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.
    `RepositoryResult<Resource>` | `getContextIDs()` Gets all resources that are used as content identifiers.
    `IsolationLevel` | `getIsolationLevel()` Retrieves the current `transaction isolation level` of the connection.
    `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.
    `ParserConfig` | `getParserConfig()` Returns the parser configuration this connection uses for Rio-based operations.
    `Repository` | `getRepository()` Returns the Repository object to which this connection belongs.
    `RepositoryResult<Statement>` | `getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts)` Gets all statements with a specific subject, predicate and/or object from the repository.
    `default RepositoryResult<Statement>` | `getStatements(Resource subj, IRI pred, Value obj, Resource... contexts)` Gets all statements with a specific subject, predicate and/or object from the repository.
    `default RepositoryResult<Statement>` | `getStatements(Resource subj, URI pred, Value obj, boolean includeInferred, Resource... contexts)` Deprecated. since 2.0. Use `getStatements(Resource, IRI, Value, boolean, Resource...)` instead.
    `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.
    `default boolean` | `hasStatement(Resource subj, URI pred, Value obj, boolean includeInferred, Resource... contexts)` Deprecated. since 2.0. Use `hasStatement(Resource, IRI, Value, boolean, Resource...)` instead.
    `boolean` | `hasStatement(Statement st, boolean includeInferred, Resource... contexts)` Checks whether the repository contains the specified statement, optionally in the specified contexts.
    `boolean` | `isActive()` Indicates if a transaction is currently active on the connection.
    `boolean` | `isAutoCommit()` Deprecated. since 2.0. Use `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`.
    `BooleanQuery` | `prepareBooleanQuery(QueryLanguage ql, String query, String baseURI)` Prepares queries that return `true` or `false`.
    `default BooleanQuery` | `prepareBooleanQuery(String query)` Prepares SPARQL queries that return `true` or `false`, that is, SPARQL ASK 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.
    `default GraphQuery` | `prepareGraphQuery(String query)` Prepares SPARQL queries that produce RDF graphs, that is, SPARQL CONSTRUCT or DESCRIBE queries.
    `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).
    `default Query` | `prepareQuery(String query)` Prepares a SPARQL 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.
    `default TupleQuery` | `prepareTupleQuery(String query)` Prepares a SPARQL query that produces sets of value tuples, that is a SPARQL SELECT query.
    `Update` | `prepareUpdate(QueryLanguage ql, String update)` Prepares an Update operation.
    `Update` | `prepareUpdate(QueryLanguage ql, String update, String baseURI)` Prepares an Update operation.
    `default Update` | `prepareUpdate(String update)` Prepares a SPARQL 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.
    `default void` | `remove(Resource subject, URI predicate, Value object, Resource... contexts)` Deprecated. since 2.0. Use `remove(Resource, IRI, Value, Resource...)` instead.
    `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 in the active transaction.
    `void` | `setAutoCommit(boolean autoCommit)` Deprecated. As of release 2.7.0, use `begin()` instead.
    `void` | `setIsolationLevel(IsolationLevel level)` Sets the transaction isolation level for the next transaction(s) on this connection.
    `void` | `setNamespace(String prefix, String name)` Sets the prefix for a namespace.
    `void` | `setParserConfig(ParserConfig config)` Set the parser configuration this connection should use for RDFParser-based operations.
    `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.

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

    - #### 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

          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.

    - #### prepareQuery

          default Query prepareQuery(String query)
                              throws RepositoryException,
                                     MalformedQueryException

      Prepares a SPARQL 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:
        `query` - The query string, in SPARQL syntax.
      Returns:
        A query ready to be evaluated on this repository.
      Throws:
        `MalformedQueryException` - If the supplied query is malformed.
        `UnsupportedOperationException` - If the `prepareQuery` method is not supported by this repository.
        `RepositoryException`
      See Also:
        `prepareQuery(QueryLanguage, String)`

    - #### 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

          default TupleQuery prepareTupleQuery(String query)
                                        throws RepositoryException,
                                               MalformedQueryException

      Prepares a SPARQL query that produces sets of value tuples, that is a SPARQL SELECT query. 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:
        `query` - The query string, in SPARQL syntax.
      Returns:
        a `TupleQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `IllegalArgumentException` - If the supplied query is not a tuple query.
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`
      See Also:
        `prepareTupleQuery(QueryLanguage, String)`

    - #### 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.
      Returns:
        a `TupleQuery` ready to be evaluated on this `RepositoryConnection`.
      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.
      Returns:
        a `TupleQuery` ready to be evaluated on this `RepositoryConnection`.
      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

          default GraphQuery prepareGraphQuery(String query)
                                        throws RepositoryException,
                                               MalformedQueryException

      Prepares SPARQL queries that produce RDF graphs, that is, SPARQL CONSTRUCT or DESCRIBE queries. 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:
        `query` - The query string, in SPARQL syntax.
      Returns:
        a `GraphQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `IllegalArgumentException` - If the supplied query is not a graph query.
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`
      See Also:
        `prepareGraphQuery(QueryLanguage, String)`

    - #### 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.
      Returns:
        a `GraphQuery` ready to be evaluated on this `RepositoryConnection`.
      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.
      Returns:
        a `GraphQuery` ready to be evaluated on this `RepositoryConnection`.
      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

          default BooleanQuery prepareBooleanQuery(String query)
                                            throws RepositoryException,
                                                   MalformedQueryException

      Prepares SPARQL queries that return `true` or `false`, that is, SPARQL ASK 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:
        `query` - The query string, in SPARQL syntax.
      Returns:
        a `BooleanQuery` ready to be evaluated on this `RepositoryConnection`.
      Throws:
        `IllegalArgumentException` - If the supplied query is not a boolean query.
        `MalformedQueryException` - If the supplied SPARQL query is malformed.
        `RepositoryException`
      See Also:
        `prepareBooleanQuery(QueryLanguage, String)`

    - #### prepareBooleanQuery

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

      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 `prepareBooleanQuery(QueryLanguage, String, String)` instead.
      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:
        `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 queries that return `true` or `false`.
      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 `BooleanQuery` ready to be evaluated on this `RepositoryConnection`.
      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`

    - #### prepareUpdate

          default Update prepareUpdate(String update)
                                throws RepositoryException,
                                       MalformedQueryException

      Prepares a SPARQL Update operation. In case the update string contains relative URIs that need to be resolved against an external base URI, one should use `prepareUpdate(QueryLanguage, String, String)` instead.
      Parameters:
        `update` - The update operation string, in SPARQL syntax.
      Returns:
        a `Update` ready to be executed on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied update operation string is malformed.
        `RepositoryException`
      See Also:
        `prepareUpdate(QueryLanguage, String)`

    - #### prepareUpdate

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

      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 `prepareUpdate(QueryLanguage, String, String)` instead.
      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`

    - #### prepareUpdate

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

      Prepares an Update operation.
      Parameters:
        `ql` - The `query language` in which the update operation is formulated.
        `update` - The update operation string.
        `baseURI` - The base URI to resolve any relative URIs that are in the update against, can be `null` if the update does not contain any relative URIs.
      Returns:
        a `Update` ready to be executed on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied update operation string is malformed.
        `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

          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 `Statement`s and optionally throwing a `RepositoryException` when an error when a problem occurs during retrieval.
      Throws:
        `RepositoryException`

    - #### getStatements

          @Deprecated
          default RepositoryResult<Statement> getStatements(Resource subj,
                                                                        URI pred,
                                                                        Value obj,
                                                                        boolean includeInferred,
                                                                        Resource... contexts)
                                                                 throws RepositoryException

      Deprecated. since 2.0. Use `getStatements(Resource, IRI, Value, boolean, Resource...)` instead.
      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 `Statement`s 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 `Statement`s 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

          @Deprecated
          default boolean hasStatement(Resource subj,
                                                   URI pred,
                                                   Value obj,
                                                   boolean includeInferred,
                                                   Resource... contexts)
                                            throws RepositoryException

      Deprecated. since 2.0. Use `hasStatement(Resource, IRI, Value, boolean, Resource...)` instead.
      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,
                                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.
      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

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

    - #### isActive

          boolean isActive()
                    throws UnknownTransactionStateException,
                           RepositoryException

      Indicates if a transaction is currently active on the connection. A transaction is active if `begin()` has been called, and becomes inactive after `commit()` or `rollback()` has been called.
      Returns:
        `true` iff a transaction is active, `false` iff no transaction is active.
      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`

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

    - #### getIsolationLevel

          IsolationLevel getIsolationLevel()

      Retrieves the current `transaction isolation level` of the connection.
      Returns:
        the current transaction isolation level.

    - #### begin

          void begin()
              throws RepositoryException

      Begins a new transaction, requiring `commit()` or `rollback()` to be called to end the transaction. The transaction will use the currently set `isolation level` for this connection.
      Throws:
        `RepositoryException` - If the connection could not start the transaction. One possible reason this may happen is if a transaction is already `active` on the current connection.
      See Also:
        `begin(IsolationLevel)`, `isActive()`, `commit()`, `rollback()`, `setIsolationLevel(IsolationLevel)`

    - #### begin

          void begin(IsolationLevel level)
              throws RepositoryException

      Begins a new transaction with the supplied `IsolationLevel`, requiring `commit()` or `rollback()` to be called to end the transaction.
      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:
        `begin()`, `isActive()`, `commit()`, `rollback()`, `#setIsolationLevel()`

    - #### commit

          void commit()
               throws RepositoryException

      Commits 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 connection could not be committed, or if the connection does not have an active transaction.
      See Also:
        `isActive()`, `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

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

          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,
                   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

          @Deprecated
          default void add(Resource subject,
                                       URI predicate,
                                       Value object,
                                       Resource... contexts)
                                throws RepositoryException

      Deprecated. since 2.0. Use `add(Resource, IRI, Value, Resource...)` instead.
      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,
                      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

          @Deprecated
          default void remove(Resource subject,
                                          URI predicate,
                                          Value object,
                                          Resource... contexts)
                                   throws RepositoryException

      Deprecated. since 2.0. Use `remove(Resource, IRI, Value, Resource...)` instead.
      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, 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.

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