Package org.eclipse.rdf4j.spring.resultcache

## Class CachingRepositoryConnection

- java.lang.Object
- - org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection
  - - org.eclipse.rdf4j.repository.base.RepositoryConnectionWrapper
    - - org.eclipse.rdf4j.spring.resultcache.CachingRepositoryConnection

- All Implemented Interfaces:
    `AutoCloseable`, `DelegatingRepositoryConnection`, `RepositoryConnection`, `Clearable`

      public class CachingRepositoryConnection
      extends RepositoryConnectionWrapper
      implements Clearable

  Since:
    4.0.0
  Author:
    Florian Kleedorfer

- - ### Field Summary

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

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `CachingRepositoryConnection​(RepositoryConnection delegate, LRUResultCache<ReusableTupleQueryResult> globalTupleQueryResultCache, LRUResultCache<ReusableGraphQueryResult> globalGraphQueryResultCache, ResultCacheProperties properties)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | 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​(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​(Iterable<? extends Statement> statements, Resource... contexts)` | Adds the supplied statements 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.
    `<E extends Exception> void` | `add​(Iteration<? extends Statement,​E> statementIter, Resource... contexts)` | Adds the supplied statements to this repository, optionally to one or more named contexts.
    `void` | `add​(Resource subject, IRI predicate, Value object, Resource... contexts)` | Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
    `void` | `add​(Statement st, Resource... contexts)` | Adds the supplied statement to this repository, optionally to one or more named contexts.
    `void` | `clear​(Resource... contexts)` | Removes all statements from a specific contexts in the repository.
    `void` | `clearCachedResults()` |
    `void` | `close()` | Closes the connection, freeing resources.
    `void` | `markDirty()` | As we are changing the repository's content, we have to reset all caches (even though it
    `GraphQuery` | `prepareGraphQuery​(QueryLanguage ql, String queryString, String baseURI)` | Prepares queries that produce RDF graphs.
    `TupleQuery` | `prepareTupleQuery​(QueryLanguage ql, String queryString, String baseURI)` | Prepares a query that produces sets of value tuples.
    `Update` | `prepareUpdate​(QueryLanguage ql, String updateString, 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.
    `<E extends Exception> void` | `remove​(Iteration<? extends Statement,​E> statementIter, Resource... contexts)` | Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
    `void` | `remove​(Resource subject, IRI predicate, Value object, Resource... contexts)` | Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
    `void` | `remove​(Statement st, Resource... contexts)` | Removes the supplied statement from the specified contexts in the repository.
    `void` | `removeNamespace​(String prefix)` | Removes a namespace declaration by removing the association between a prefix and a namespace name.
    `void` | `renewClearable​(ClearableAwareUpdate update)` |
    `void` | `renewLocalResultCache​(ResultCachingGraphQuery resultCachingGraphQuery)` |
    `void` | `renewLocalResultCache​(ResultCachingTupleQuery resultCachingTupleQuery)` |

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

      `addWithoutCommit, begin, begin, begin, clearNamespaces, commit, exportStatements, exportStatements, getContextIDs, getDelegate, getIsolationLevel, getNamespace, getNamespaces, getStatements, hasStatement, hasStatement, isActive, isAutoCommit, isDelegatingAdd, isDelegatingRead, isDelegatingRemove, isEmpty, isOpen, prepare, prepareBooleanQuery, prepareQuery, removeWithoutCommit, rollback, setAutoCommit, setDelegate, setIsolationLevel, setNamespace, setParserConfig, size`

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

      `addWithoutCommit, conditionalCommit, conditionalRollback, export, getParserConfig, getRepository, getValueFactory, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, removeWithoutCommit, startLocalTransaction`

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

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

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

      `add, add, add, add, add, add, add, export, getParserConfig, getRepository, getStatements, getValueFactory, prepareBooleanQuery, prepareBooleanQuery, prepareGraphQuery, prepareGraphQuery, prepareQuery, prepareQuery, prepareTupleQuery, prepareTupleQuery, prepareUpdate, prepareUpdate, remove`

- - ### Constructor Detail

    - #### CachingRepositoryConnection

          public CachingRepositoryConnection​(RepositoryConnection delegate,
                                             LRUResultCache<ReusableTupleQueryResult> globalTupleQueryResultCache,
                                             LRUResultCache<ReusableGraphQueryResult> globalGraphQueryResultCache,
                                             ResultCacheProperties properties)

  - ### Method Detail

    - #### renewLocalResultCache

          public void renewLocalResultCache​(ResultCachingTupleQuery resultCachingTupleQuery)

    - #### renewLocalResultCache

          public void renewLocalResultCache​(ResultCachingGraphQuery resultCachingGraphQuery)

    - #### renewClearable

          public void renewClearable​(ClearableAwareUpdate update)

    - #### prepareTupleQuery

          public TupleQuery prepareTupleQuery​(QueryLanguage ql,
                                              String queryString,
                                              String baseURI)
                                       throws MalformedQueryException,
                                              RepositoryException

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

    - #### prepareGraphQuery

          public GraphQuery prepareGraphQuery​(QueryLanguage ql,
                                              String queryString,
                                              String baseURI)
                                       throws MalformedQueryException,
                                              RepositoryException

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

    - #### prepareUpdate

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

      Description copied from interface: `RepositoryConnection`
      Prepares an Update operation.
      Specified by:
        `prepareUpdate` in interface `RepositoryConnection`
      Overrides:
        `prepareUpdate` in class `RepositoryConnectionWrapper`
      Parameters:
        `ql` - The `query language` in which the update operation is formulated.
        `updateString` - 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`

    - #### 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 `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException` - If the connection could not be closed.

    - #### markDirty

          public void markDirty()

      As we are changing the repository's content, we have to reset all caches (even though it
      Specified by:
        `markDirty` in interface `Clearable`

    - #### clearCachedResults

          public void clearCachedResults()

      Specified by:
        `clearCachedResults` in interface `Clearable`

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

    - #### add

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

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

    - #### add

          public void add​(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 `RepositoryConnectionWrapper`
      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​(Resource subject,
                          IRI predicate,
                          Value object,
                          Resource... contexts)
                   throws RepositoryException

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

          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 `RepositoryConnectionWrapper`
      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​(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 `RepositoryConnectionWrapper`
      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.

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

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

    - #### remove

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

      Description copied from interface: `RepositoryConnection`
      Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
      Specified by:
        `remove` in interface `RepositoryConnection`
      Overrides:
        `remove` in class `RepositoryConnectionWrapper`
      Parameters:
        `statementIter` - The statements to remove. In case the iteration is a `CloseableIteration`, it will be closed before this method returns.
        `contexts` - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
      Throws:
        `RepositoryException` - If the statements could not be removed from the repository, for example because the repository is not writable.
        `E extends Exception`

    - #### remove

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

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

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

    - #### 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`
      Overrides:
        `removeNamespace` in class `RepositoryConnectionWrapper`
      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.