org.eclipse.rdf4j.repository.sparql

## Class SPARQLConnection

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

- All Implemented Interfaces:
    AutoCloseable, HttpClientDependent, RepositoryConnection

      public class SPARQLConnection
      extends AbstractRepositoryConnection
      implements HttpClientDependent

  Provides a `RepositoryConnection` interface to any SPARQL endpoint.
  Author:
    James Leigh

- - ### Field Summary

    - ### Fields inherited from class org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SPARQLConnection(SPARQLRepository repository, SPARQLProtocolSession client)`
    `SPARQLConnection(SPARQLRepository repository, SPARQLProtocolSession client, boolean quadMode)`

  - ### Method Summary

    All Methods Instance 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.
    `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(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 void` | `addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `protected void` | `addWithoutCommit(Statement st, Resource... contexts)`
    `void` | `begin()` Begins a new transaction, 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` | `clearNamespaces()` Removes all namespace declarations from the repository.
    `void` | `close()` Closes the connection, freeing resources.
    `void` | `commit()` Commits the active transaction.
    `void` | `enableSilentMode(boolean flag)` Deprecated. since 3.6.0 - use `setSilentClear(boolean)` instead.
    `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.
    `org.apache.http.client.HttpClient` | `getHttpClient()` `HttpClient` that has been assigned or has been used by this object.
    `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.
    `SPARQLRepository` | `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.
    `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` | `isActive()` Indicates if a transaction is currently active on the connection.
    `boolean` | `isEmpty()` Returns `true` if this repository does not contain any (explicit) statements.
    `protected boolean` | `isQuadMode()` Shall graph information also be retrieved, e.g.
    `protected boolean` | `isSilentClear()`
    `void` | `prepare()` Checks for an error state in the active transaction that would force the transaction to be rolled back.
    `BooleanQuery` | `prepareBooleanQuery(QueryLanguage ql, String query, String base)` Prepares queries that return `true` or `false`.
    `GraphQuery` | `prepareGraphQuery(QueryLanguage ql, String query, String base)` Prepares queries that produce RDF graphs.
    `Query` | `prepareQuery(QueryLanguage ql, String query, String base)` Prepares a query for evaluation on this repository (optional operation).
    `TupleQuery` | `prepareTupleQuery(QueryLanguage ql, String query, String base)` Prepares a query that produces sets of value tuples.
    `Update` | `prepareUpdate(QueryLanguage ql, String update, String baseURI)` Prepares an Update operation.
    `void` | `remove(Iterable<? extends Statement> statements, Resource... contexts)` Removes the supplied statements from the specified contexts in this repository.
    `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.
    `protected void` | `removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `protected void` | `removeWithoutCommit(Statement st, Resource... contexts)`
    `void` | `rollback()` Rolls back all updates in the active transaction.
    `void` | `setHttpClient(org.apache.http.client.HttpClient httpClient)` Assign an `HttpClient` that this object should use.
    `void` | `setNamespace(String prefix, String name)` Sets the prefix for a namespace.
    `void` | `setParserConfig(ParserConfig parserConfig)` Set the parser configuration this connection should use for RDFParser-based operations.
    `void` | `setSilentClear(boolean silent)` Configure the connection to execute `clear(Resource...)` operations silently: the remote endpoint will not respond with an error if the supplied named graph does not exist on the endpoint.
    `long` | `size(Resource... contexts)` Returns the number of (explicit) statements that are in the specified contexts in this repository.
    `protected Iteration<Statement,QueryEvaluationException>` | `toStatementIteration(TupleQueryResult iter, Resource subj, IRI pred, Value obj)` Converts a `TupleQueryResult` resulting from the `EVERYTHING_WITH_GRAPH` to a statement by using the respective values from the `BindingSet` or (if provided) the ones from the arguments.
    `String` | `toString()`

    - ### Methods inherited from class org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection

      `add, add, begin, conditionalCommit, conditionalRollback, export, getIsolationLevel, getParserConfig, getValueFactory, hasStatement, isAutoCommit, isOpen, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, remove, remove, setAutoCommit, setIsolationLevel, startLocalTransaction`

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

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

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

      `add, add, add, add, add, add, add, add, begin, getStatements, getStatements, hasStatement, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, remove, remove`

- - ### Constructor Detail

    - #### SPARQLConnection

          public SPARQLConnection(SPARQLRepository repository,
                                  SPARQLProtocolSession client)

    - #### SPARQLConnection

          public SPARQLConnection(SPARQLRepository repository,
                                  SPARQLProtocolSession client,
                                  boolean quadMode)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### setSilentClear

          public void setSilentClear(boolean silent)

      Configure the connection to execute `clear(Resource...)` operations silently: the remote endpoint will not respond with an error if the supplied named graph does not exist on the endpoint.

      By default, the SPARQL connection executes the `clear(Resource...)` API operation by converting it to a SPARQL `CLEAR GRAPH` update operation. This operation has an optional `SILENT` modifier, which can be enabled by setting this flag to `true`. The behavior of this modifier is speficied as follows in the SPARQL 1.1 Recommendation:

      > If the store records the existence of empty graphs, then the SPARQL 1.1 Update service, by default, SHOULD return failure if the specified graph does not exist. If SILENT is present, the result of the operation will always be success.

      > Stores that do not record empty graphs will always return success.

      Note that in most SPARQL endpoint implementations not recording empty graphs is the default behavior, and setting this flag to `true` will have no effect. Setting this flag will have no effect on any other errors or other API or SPARQL operations: only the behavior of the `clear(Resource...)` API operation is modified to respond with a success message when removing a non-existent named graph.
      Parameters:
        `silent` - the value to set this to.
      See Also:
        `https://www.w3.org/TR/sparql11-update/#clear`

    - #### enableSilentMode

          @Deprecated
          public void enableSilentMode(boolean flag)

      Deprecated. since 3.6.0 - use `setSilentClear(boolean)` instead.
      Configure the connection to execute `clear(Resource...)` operations silently: the remote endpoint will not respond with an error if the supplied named graph does not exist on the endpoint.

      By default, the SPARQL connection executes the `clear(Resource...)` API operation by converting it to a SPARQL `CLEAR GRAPH` update operation. This operation has an optional `SILENT` modifier, which can be enabled by setting this flag to `true`. The behavior of this modifier is speficied as follows in the SPARQL 1.1 Recommendation:

      > If the store records the existence of empty graphs, then the SPARQL 1.1 Update service, by default, SHOULD return failure if the specified graph does not exist. If SILENT is present, the result of the operation will always be success.

      > Stores that do not record empty graphs will always return success.

      Note that in most SPARQL endpoint implementations not recording empty graphs is the default behavior, and setting this flag to `true` will have no effect. Setting this flag will have no effect on any other errors or other API or SPARQL operations: only the behavior of the `clear(Resource...)` API operation is modified to respond with a success message when removing a non-existent named graph.
      Parameters:
        `silent` - the value to set this to.
      See Also:
        `https://www.w3.org/TR/sparql11-update/#clear`

    - #### 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`
      Overrides:
        `setParserConfig` in class `AbstractRepositoryConnection`
      Parameters:
        `parserConfig` - a Rio RDF Parser configuration.

    - #### getHttpClient

          public final org.apache.http.client.HttpClient getHttpClient()

      Description copied from interface: `HttpClientDependent`
      `HttpClient` that has been assigned or has been used by this object. The life cycle might not be or might be tied to this object, depending on whether `HttpClient` was passed to or created by this object respectively.
      Specified by:
        `getHttpClient` in interface `HttpClientDependent`
      Returns:
        an `HttpClient` instance or null

    - #### setHttpClient

          public void setHttpClient(org.apache.http.client.HttpClient httpClient)

      Description copied from interface: `HttpClientDependent`
      Assign an `HttpClient` that this object should use. The life cycle of the given `HttpClient` is independent of this object. Closing or shutting down this object does not have any impact on the given client. Callers must ensure that the given client is properly closed elsewhere.
      Specified by:
        `setHttpClient` in interface `HttpClientDependent`

    - #### 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`
      Overrides:
        `close` in class `AbstractRepositoryConnection`
      Throws:
        `RepositoryException` - If the connection could not be closed.

    - #### exportStatements

          public void exportStatements(Resource subj,
                                       IRI pred,
                                       Value obj,
                                       boolean includeInferred,
                                       RDFHandler handler,
                                       Resource... contexts)
                                throws RepositoryException,
                                       RDFHandlerException

      Description copied from interface: `RepositoryConnection`
      Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts. This method supplies the RDFHandler with all namespace declarations available in the repository.
      Specified by:
        `exportStatements` in interface `RepositoryConnection`
      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.
        `includeInferred` - if false, no inferred statements are returned; if true, inferred statements are returned if available
        `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`

    - #### getContextIDs

          public RepositoryResult<Resource> getContextIDs()
                                                   throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      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.
      Specified by:
        `getContextIDs` in interface `RepositoryConnection`
      Returns:
        a RepositoryResult object containing Resources that are used as context identifiers.
      Throws:
        `RepositoryException`

    - #### getNamespace

          public String getNamespace(String prefix)
                              throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Gets the namespace that is associated with the specified prefix, if any.
      Specified by:
        `getNamespace` in interface `RepositoryConnection`
      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.

    - #### getNamespaces

          public RepositoryResult<Namespace> getNamespaces()
                                                    throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Gets all declared namespaces as a RepositoryResult of `Namespace` objects. Each Namespace object consists of a prefix and a namespace name.
      Specified by:
        `getNamespaces` in interface `RepositoryConnection`
      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.

    - #### 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`
      Overrides:
        `isEmpty` in class `AbstractRepositoryConnection`
      Returns:
        `true` if this repository is empty, `false` otherwise.
      Throws:
        `RepositoryException` - If the repository could not be checked to be empty.

    - #### size

          public long size(Resource... contexts)
                    throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Returns the number of (explicit) statements that are in the specified contexts in this repository.
      Specified by:
        `size` in interface `RepositoryConnection`
      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`

    - #### getStatements

          public RepositoryResult<Statement> getStatements(Resource subj,
                                                           IRI pred,
                                                           Value obj,
                                                           boolean includeInferred,
                                                           Resource... contexts)
                                                    throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      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.
      Specified by:
        `getStatements` 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 returned; if true, inferred statements are returned if available. The default is true.
        `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`

    - #### 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`
      Overrides:
        `hasStatement` in class `AbstractRepositoryConnection`
      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`

    - #### getRepository

          public SPARQLRepository getRepository()

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

    - #### prepareQuery

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

      Description copied from interface: `RepositoryConnection`
      Prepares a query for evaluation on this repository (optional operation).

      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.
        `base` - 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.
        `RepositoryException`

    - #### prepareBooleanQuery

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

      Description copied from interface: `RepositoryConnection`
      Prepares queries that return `true` or `false`.
      Specified by:
        `prepareBooleanQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
        `base` - 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:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepareGraphQuery

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

      Description copied from interface: `RepositoryConnection`
      Prepares queries that produce RDF graphs.
      Specified by:
        `prepareGraphQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
        `base` - 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:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepareTupleQuery

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

      Description copied from interface: `RepositoryConnection`
      Prepares a query that produces sets of value tuples.
      Specified by:
        `prepareTupleQuery` in interface `RepositoryConnection`
      Parameters:
        `ql` - The `query language` in which the query is formulated.
        `query` - The query string.
        `base` - 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:
        `MalformedQueryException` - If the supplied query is malformed.
        `RepositoryException`

    - #### prepare

          public void prepare()
                       throws RepositoryException

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

    - #### commit

          public void commit()
                      throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Commits the active transaction. This operation ends the active transaction.
      Specified by:
        `commit` in interface `RepositoryConnection`
      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:
        `RepositoryConnection.isActive()`, `RepositoryConnection.begin()`, `RepositoryConnection.rollback()`, `RepositoryConnection.prepare()`

    - #### rollback

          public void rollback()
                        throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Rolls back all updates in the active transaction. This operation ends the active transaction.
      Specified by:
        `rollback` in interface `RepositoryConnection`
      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:
        `RepositoryConnection.isActive()`, `RepositoryConnection.begin()`, `RepositoryConnection.commit()`

    - #### begin

          public void begin()
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Begins a new transaction, requiring `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` to be called to end the transaction. The transaction will use the currently set `isolation level` for this connection.
      Specified by:
        `begin` in interface `RepositoryConnection`
      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:
        `RepositoryConnection.begin(IsolationLevel)`, `RepositoryConnection.isActive()`, `RepositoryConnection.commit()`, `RepositoryConnection.rollback()`, `RepositoryConnection.setIsolationLevel(IsolationLevel)`

    - #### 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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      Parameters:
        `file` - A file containing RDF data.
        `baseURI` - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of `file.toURI()` if the value is set to `null`.

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

        `dataFormat` - The serialization format of the data. If set to `null`, the format will be automatically determined by examining the file name extension of the supplied File.
        `contexts` - The contexts to add the data to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the data is added to any context specified in the actual data file, or if the data contains no context, it is added without context. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
      Throws:
        `IOException` - If an I/O error occurred while reading from the file.
        `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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      Parameters:
        `url` - The URL of the RDF data.
        `baseURI` - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of `url.toExternalForm()` if the value is set to `null`.

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

        `dataFormat` - The serialization format of the data. If set to `null`, the format will be automatically determined by examining the content type in the HTTP response header, and failing that, the file name extension of the supplied URL.
        `contexts` - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
      Throws:
        `IOException` - If an I/O error occurred while reading from the URL.
        `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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      Parameters:
        `in` - An InputStream from which RDF data can be read.
        `baseURI` - The base URI to resolve any relative URIs that are in the data against. May be `null`.

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

        `dataFormat` - The serialization format of the data.
        `contexts` - The contexts to add the data to. If one or more contexts are supplied the method ignores contextual information in the actual data. If no contexts are supplied the contextual information in the input stream is used, if no context information is available the data is added without any context.
      Throws:
        `IOException` - If an I/O error occurred while reading from the input stream.
        `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(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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      Parameters:
        `reader` - A Reader from which RDF data can be read.
        `baseURI` - The base URI to resolve any relative URIs that are in the data against. May be `null`.

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

        `dataFormat` - The serialization format of the data.
        `contexts` - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
      Throws:
        `IOException` - If an I/O error occurred while reading from the reader.
        `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(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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      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(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`
      Overrides:
        `add` in class `AbstractRepositoryConnection`
      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.

    - #### 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`
      Overrides:
        `clear` in class `AbstractRepositoryConnection`
      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.

    - #### clearNamespaces

          public void clearNamespaces()
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes all namespace declarations from the repository.
      Specified by:
        `clearNamespaces` in interface `RepositoryConnection`
      Throws:
        `RepositoryException` - If the namespace declarations could not be removed.

    - #### 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`
      Overrides:
        `remove` in class `AbstractRepositoryConnection`
      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(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`
      Overrides:
        `remove` in class `AbstractRepositoryConnection`
      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.

    - #### removeNamespace

          public void removeNamespace(String prefix)
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes a namespace declaration by removing the association between a prefix and a namespace name.
      Specified by:
        `removeNamespace` in interface `RepositoryConnection`
      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.

    - #### setNamespace

          public void setNamespace(String prefix,
                                   String name)
                            throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Sets the prefix for a namespace.
      Specified by:
        `setNamespace` in interface `RepositoryConnection`
      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.

    - #### prepareUpdate

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

      Description copied from interface: `RepositoryConnection`
      Prepares an Update operation.
      Specified by:
        `prepareUpdate` in interface `RepositoryConnection`
      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`

    - #### isActive

          public boolean isActive()
                           throws UnknownTransactionStateException,
                                  RepositoryException

      Description copied from interface: `RepositoryConnection`
      Indicates if a transaction is currently active on the connection. A transaction is active if `RepositoryConnection.begin()` has been called, and becomes inactive after `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` has been called.
      Specified by:
        `isActive` in interface `RepositoryConnection`
      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`

    - #### addWithoutCommit

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

      Overrides:
        `addWithoutCommit` in class `AbstractRepositoryConnection`
      Throws:
        `RepositoryException`

    - #### addWithoutCommit

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

      Specified by:
        `addWithoutCommit` in class `AbstractRepositoryConnection`
      Throws:
        `RepositoryException`

    - #### removeWithoutCommit

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

      Overrides:
        `removeWithoutCommit` in class `AbstractRepositoryConnection`
      Throws:
        `RepositoryException`

    - #### removeWithoutCommit

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

      Specified by:
        `removeWithoutCommit` in class `AbstractRepositoryConnection`
      Throws:
        `RepositoryException`

    - #### isQuadMode

          protected boolean isQuadMode()

      Shall graph information also be retrieved, e.g. for `getStatements(Resource, IRI, Value, boolean, Resource...)`
      Returns:
        true if in quad mode

    - #### isSilentClear

          protected boolean isSilentClear()

    - #### toStatementIteration

          protected Iteration<Statement,QueryEvaluationException> toStatementIteration(TupleQueryResult iter,
                                                                                       Resource subj,
                                                                                       IRI pred,
                                                                                       Value obj)

      Converts a `TupleQueryResult` resulting from the `EVERYTHING_WITH_GRAPH` to a statement by using the respective values from the `BindingSet` or (if provided) the ones from the arguments.
      Parameters:
        `iter` - the `TupleQueryResult`
        `subj` - the subject `Resource` used as input or `null` if wildcard was used
        `pred` - the predicate `IRI` used as input or `null` if wildcard was used
        `obj` - the object `Value` used as input or `null` if wildcard was used
      Returns:
        the converted iteration

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