RepositoryConnectionBase (OpenRDF Sesame 2.7.12 API)

java.lang.Object
- org.openrdf.repository.base.RepositoryConnectionBase

All Implemented Interfaces:

RepositoryConnection

Direct Known Subclasses:

RepositoryConnectionWrapper, SailRepositoryConnection, SPARQLConnection
```
public abstract class RepositoryConnectionBase
extends Object
implements RepositoryConnection
```
Abstract class implementing most 'convenience' methods in the RepositoryConnection interface by transforming parameters and mapping the methods to the basic (abstractly declared) methods.
Open connections are automatically closed when being garbage collected. A warning message will be logged when the system property org.openrdf.repository.debug has been set to a non-null value.

Author:

Jeen Broekstra, Arjohn Kampman

Field Summary

Fields
Modifier and Type Field and Description

protected org.slf4j.Logger logger

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

Constructor Summary

Constructors
Modifier Constructor and Description

protected RepositoryConnectionBase(Repository repository)

Constructors
Modifier	Constructor and Description
`protected`	`RepositoryConnectionBase(Repository repository)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts)` Adds RDF data from the specified file to a specific contexts in the repository.
`void`	`add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts)` Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
`void`	`add(Iterable<? extends Statement> statements, Resource... contexts)` Adds the supplied statements to this repository, optionally to one or more named contexts.
`<E extends Exception> void`	`add(Iteration<? extends Statement,E> statements, Resource... contexts)` Adds the supplied statements to this repository, optionally to one or more named contexts.
`void`	`add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts)` Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
`void`	`add(Resource subject, URI predicate, Value object, Resource... contexts)` Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
`void`	`add(Statement st, Resource... contexts)` Adds the supplied statement to this repository, optionally to one or more named contexts.
`void`	`add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts)` Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
`protected abstract void`	`addWithoutCommit(Resource subject, URI predicate, Value object, Resource... contexts)`
`protected void`	`addWithoutCommit(Statement st, Resource... contexts)`
`void`	`clear(Resource... contexts)` Removes all statements from a specific contexts in the repository.
`void`	`close()` Closes the connection, freeing resources.
`protected void`	`conditionalCommit(boolean condition)` Invokes `RepositoryConnection.commit()` if supplied boolean condition is `true`.
`protected void`	`conditionalRollback(boolean condition)` Invokes `RepositoryConnection.rollback()` if supplied boolean condition is `true`.
`void`	`export(RDFHandler handler, Resource... contexts)` Exports all explicit statements in the specified contexts to the supplied RDFHandler.
`ParserConfig`	`getParserConfig()` Returns the parser configuration this connection uses for Rio-based operations.
`Repository`	`getRepository()` Returns the Repository object to which this connection belongs.
`ValueFactory`	`getValueFactory()` Gets a ValueFactory for this RepositoryConnection.
`boolean`	`hasStatement(Resource subj, URI pred, Value obj, boolean includeInferred, Resource... contexts)` Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
`boolean`	`hasStatement(Statement st, boolean includeInferred, Resource... contexts)` Checks whether the repository contains the specified statement, optionally in the specified contexts.
`boolean`	`isAutoCommit()` Deprecated. since 2.7.0. Use `RepositoryConnection.isActive()` instead.
`boolean`	`isEmpty()` Returns `true` if this repository does not contain any (explicit) statements.
`boolean`	`isOpen()` Checks whether this connection is open.
`BooleanQuery`	`prepareBooleanQuery(QueryLanguage ql, String query)` Prepares `true`/`false` queries.
`GraphQuery`	`prepareGraphQuery(QueryLanguage ql, String query)` Prepares queries that produce RDF graphs.
`Query`	`prepareQuery(QueryLanguage ql, String query)` Prepares a query for evaluation on this repository (optional operation).
`TupleQuery`	`prepareTupleQuery(QueryLanguage ql, String query)` Prepares a query that produces sets of value tuples.
`Update`	`prepareUpdate(QueryLanguage ql, String update)` Prepares an Update operation.
`void`	`remove(Iterable<? extends Statement> statements, Resource... contexts)` Removes the supplied statements from the specified contexts in this repository.
`<E extends Exception> void`	`remove(Iteration<? extends Statement,E> statements, Resource... contexts)` Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
`void`	`remove(Resource subject, URI predicate, Value object, Resource... contexts)` Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
`void`	`remove(Statement st, Resource... contexts)` Removes the supplied statement from the specified contexts in the repository.
`protected abstract void`	`removeWithoutCommit(Resource subject, URI predicate, Value object, Resource... contexts)`
`protected void`	`removeWithoutCommit(Statement st, Resource... contexts)`
`void`	`setAutoCommit(boolean autoCommit)` Deprecated. since 2.7.0. Use `RepositoryConnection.begin()` instead.
`void`	`setParserConfig(ParserConfig parserConfig)` Set the parser configuration this connection should use for RDFParser-based operations.
`protected boolean`	`startLocalTransaction()` Starts a new transaction if one is not already active.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.openrdf.repository.RepositoryConnection
begin, clearNamespaces, commit, exportStatements, getContextIDs, getNamespace, getNamespaces, getStatements, isActive, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, removeNamespace, rollback, setNamespace, size

- Field Detail
  - logger
```
protected final org.slf4j.Logger logger
```
- Constructor Detail
  - RepositoryConnectionBase
```
protected RepositoryConnectionBase(Repository repository)
```
- Method Detail
  - setParserConfig
```
public void setParserConfig(ParserConfig parserConfig)
```
    Description copied from interface: RepositoryConnection
    
    Set the parser configuration this connection should use for RDFParser-based operations.
    
    Specified by:
    
    setParserConfig in interface RepositoryConnection
    
    Parameters:
    
    parserConfig - a Rio RDF Parser configuration.
  - getParserConfig
```
public ParserConfig getParserConfig()
```
    Description copied from interface: RepositoryConnection
    
    Returns the parser configuration this connection uses for Rio-based operations.
    
    Specified by:
    
    getParserConfig in interface RepositoryConnection
    
    Returns:
    
    a Rio RDF parser configuration.
  - getRepository
```
public Repository getRepository()
```
    Description copied from interface: RepositoryConnection
    
    Returns the Repository object to which this connection belongs.
    
    Specified by:
    
    getRepository in interface RepositoryConnection
  - getValueFactory
```
public ValueFactory getValueFactory()
```
    Description copied from interface: RepositoryConnection
    
    Gets a ValueFactory for this RepositoryConnection.
    
    Specified by:
    
    getValueFactory in interface RepositoryConnection
    
    Returns:
    
    A repository-specific ValueFactory.
  - isOpen
```
public boolean isOpen()
               throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Checks whether this connection is open. A connection is open from the moment it is created until it is closed.
    
    Specified by:
    
    isOpen in interface RepositoryConnection
    
    Throws:
    
    RepositoryException
    
    See Also:
    
    RepositoryConnection.close()
  - close
```
public void close()
           throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Closes the connection, freeing resources. If a transaction is active on the connection, all non-committed operations will be lost.
    
    Specified by:
    
    close in interface RepositoryConnection
    
    Throws:
    
    RepositoryException - If the connection could not be closed.
  - prepareQuery
```
public Query prepareQuery(QueryLanguage ql,
                          String query)
                   throws MalformedQueryException,
                          RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Prepares a query for evaluation on this repository (optional operation). In case the query contains relative URIs that need to be resolved against an external base URI, one should use RepositoryConnection.prepareQuery(QueryLanguage, String, String) instead.
    
    Specified by:
    
    prepareQuery in interface RepositoryConnection
    
    Parameters:
    
    ql - The query language in which the query is formulated.
    
    query - The query string.
    
    Returns:
    
    A query ready to be evaluated on this repository.
    
    Throws:
    
    MalformedQueryException - If the supplied query is malformed.
    
    RepositoryException
  - prepareTupleQuery
```
public TupleQuery prepareTupleQuery(QueryLanguage ql,
                                    String query)
                             throws MalformedQueryException,
                                    RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Prepares a query that produces sets of value tuples. In case the query contains relative URIs that need to be resolved against an external base URI, one should use RepositoryConnection.prepareTupleQuery(QueryLanguage, String, String) instead.
    
    Specified by:
    
    prepareTupleQuery in interface RepositoryConnection
    
    Parameters:
    
    ql - The query language in which the query is formulated.
    
    query - The query string.
    
    Throws:
    
    MalformedQueryException - If the supplied query is malformed.
    
    RepositoryException
  - prepareGraphQuery
```
public GraphQuery prepareGraphQuery(QueryLanguage ql,
                                    String query)
                             throws MalformedQueryException,
                                    RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Prepares queries that produce RDF graphs. In case the query contains relative URIs that need to be resolved against an external base URI, one should use RepositoryConnection.prepareGraphQuery(QueryLanguage, String, String) instead.
    
    Specified by:
    
    prepareGraphQuery in interface RepositoryConnection
    
    Parameters:
    
    ql - The query language in which the query is formulated.
    
    query - The query string.
    
    Throws:
    
    MalformedQueryException - If the supplied query is malformed.
    
    RepositoryException
  - prepareBooleanQuery
```
public BooleanQuery prepareBooleanQuery(QueryLanguage ql,
                                        String query)
                                 throws MalformedQueryException,
                                        RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Prepares true/false queries. In case the query contains relative URIs that need to be resolved against an external base URI, one should use RepositoryConnection.prepareBooleanQuery(QueryLanguage, String, String) instead.
    
    Specified by:
    
    prepareBooleanQuery in interface RepositoryConnection
    
    Parameters:
    
    ql - The query language in which the query is formulated.
    
    query - The query string.
    
    Throws:
    
    MalformedQueryException - If the supplied query is malformed.
    
    RepositoryException
  - prepareUpdate
```
public Update prepareUpdate(QueryLanguage ql,
                            String update)
                     throws MalformedQueryException,
                            RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Prepares an Update operation.
    
    Specified by:
    
    prepareUpdate in interface RepositoryConnection
    
    Parameters:
    
    ql - The query language in which the update operation is formulated.
    
    update - The update operation string.
    
    Throws:
    
    MalformedQueryException - If the supplied update operation string is malformed.
    
    RepositoryException
  - hasStatement
```
public boolean hasStatement(Resource subj,
                            URI pred,
                            Value obj,
                            boolean includeInferred,
                            Resource... contexts)
                     throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
    
    Specified by:
    
    hasStatement in interface RepositoryConnection
    
    Parameters:
    
    subj - A Resource specifying the subject, or null for a wildcard.
    
    pred - A URI specifying the predicate, or null for a wildcard.
    
    obj - A Value specifying the object, or null for a wildcard.
    
    includeInferred - if false, no inferred statements are considered; if true, inferred statements are considered if available
    
    contexts - The context(s) the need to be searched. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
    
    Returns:
    
    true If a matching statement is in the repository in the specified context, false otherwise.
    
    Throws:
    
    RepositoryException
  - hasStatement
```
public boolean hasStatement(Statement st,
                            boolean includeInferred,
                            Resource... contexts)
                     throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Checks whether the repository contains the specified statement, optionally in the specified contexts.
    
    Specified by:
    
    hasStatement in interface RepositoryConnection
    
    Parameters:
    
    st - The statement to look for. Context information in the statement is ignored.
    
    includeInferred - if false, no inferred statements are considered; if true, inferred statements are considered if available
    
    contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
    
    Returns:
    
    true If the repository contains the specified statement, false otherwise.
    
    Throws:
    
    RepositoryException
  - isEmpty
```
public boolean isEmpty()
                throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Returns true if this repository does not contain any (explicit) statements.
    
    Specified by:
    
    isEmpty in interface RepositoryConnection
    
    Returns:
    
    true if this repository is empty, false otherwise.
    
    Throws:
    
    RepositoryException - If the repository could not be checked to be empty.
  - export
```
public void export(RDFHandler handler,
                   Resource... contexts)
            throws RepositoryException,
                   RDFHandlerException
```
    Description copied from interface: RepositoryConnection
    
    Exports all explicit statements in the specified contexts to the supplied RDFHandler.
    
    Specified by:
    
    export in interface RepositoryConnection
    
    Parameters:
    
    handler - The handler that will handle the RDF data.
    
    contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
    
    Throws:
    
    RDFHandlerException - If the handler encounters an unrecoverable error.
    
    RepositoryException
  - setAutoCommit
```
@Deprecated
public void setAutoCommit(boolean autoCommit)
                               throws RepositoryException
```
    Deprecated. since 2.7.0. Use RepositoryConnection.begin() instead.
    
    Description copied from interface: RepositoryConnection
    
    Enables or disables auto-commit mode for the connection. If a connection is in auto-commit mode, then all updates will be executed and committed as individual transactions. Otherwise, the updates are grouped into transactions that are terminated by a call to either RepositoryConnection.commit() or RepositoryConnection.rollback(). By default, new connections are in auto-commit mode.
    NOTE: If this connection is switched to auto-commit mode during a transaction, the transaction is committed.
    
    Specified by:
    
    setAutoCommit in interface RepositoryConnection
    
    Throws:
    
    RepositoryException - In case the mode switch failed, for example because a currently active transaction failed to commit.
    
    See Also:
    
    RepositoryConnection.commit()
  - isAutoCommit
```
@Deprecated
public boolean isAutoCommit()
                                 throws RepositoryException
```
    Deprecated. since 2.7.0. Use RepositoryConnection.isActive() instead.
    
    Description copied from interface: RepositoryConnection
    Indicates if the connection is in auto-commit mode. The connection is in auto-commit mode when no transaction is currently active, that is, when:
    1. RepositoryConnection.begin() has not been called or;
    2. RepositoryConnection.commit() or RepositoryConnection.rollback() have been called to finish the transaction.
    Specified by:
    
    isAutoCommit in interface RepositoryConnection
    
    Throws:
    
    RepositoryException - If a repository access error occurs.
  - add
```
public void add(File file,
                String baseURI,
                RDFFormat dataFormat,
                Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds RDF data from the specified file to a specific contexts in the repository.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    file - A file containing RDF data.
    
    baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of file.toURI() if the value is set to null.
    
    dataFormat - The serialization format of the data.
    
    contexts - The contexts to add the data to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the data is added to any context specified in the actual data file, or if the data contains no context, it is added without context. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
    
    Throws:
    
    IOException - If an I/O error occurred while reading from the file.
    
    RDFParseException - If an error was found while parsing the RDF data.
    
    RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
  - add
```
public void add(URL url,
                String baseURI,
                RDFFormat dataFormat,
                Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    url - The URL of the RDF data.
    
    baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the value of url.toExternalForm() if the value is set to null.
    
    dataFormat - The serialization format of the data. If set to null, the format will be automatically determined by examining the content type in the HTTP response header, and failing that, the file name extension of the supplied URL.
    
    contexts - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
    
    Throws:
    
    IOException - If an I/O error occurred while reading from the URL.
    
    RDFParseException - If an error was found while parsing the RDF data.
    
    RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
  - add
```
public void add(InputStream in,
                String baseURI,
                RDFFormat dataFormat,
                Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    in - An InputStream from which RDF data can be read.
    
    baseURI - The base URI to resolve any relative URIs that are in the data against.
    
    dataFormat - The serialization format of the data.
    
    contexts - The contexts to add the data to. If one or more contexts are supplied the method ignores contextual information in the actual data. If no contexts are supplied the contextual information in the input stream is used, if no context information is available the data is added without any context.
    
    Throws:
    
    IOException - If an I/O error occurred while reading from the input stream.
    
    RDFParseException - If an error was found while parsing the RDF data.
    
    RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
  - startLocalTransaction
```
protected final boolean startLocalTransaction()
                                       throws RepositoryException
```
    Starts a new transaction if one is not already active.
    
    Returns:
    
    true if a new transaction was started, false if a transaction was already active.
    
    Throws:
    
    RepositoryException
    
    Since:
    
    2.7.0
  - conditionalCommit
```
protected final void conditionalCommit(boolean condition)
                                throws RepositoryException
```
    Invokes RepositoryConnection.commit() if supplied boolean condition is true.
    
    Parameters:
    
    condition - a boolean condition.
    
    Throws:
    
    RepositoryException
    
    Since:
    
    2.7.0
  - conditionalRollback
```
protected final void conditionalRollback(boolean condition)
                                  throws RepositoryException
```
    Invokes RepositoryConnection.rollback() if supplied boolean condition is true.
    
    Parameters:
    
    condition - a boolean condition.
    
    Throws:
    
    RepositoryException
    
    Since:
    
    2.7.0
  - add
```
public void add(Reader reader,
                String baseURI,
                RDFFormat dataFormat,
                Resource... contexts)
         throws IOException,
                RDFParseException,
                RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds RDF data from a Reader to the repository, optionally to one or more named contexts. Note: using a Reader to upload byte-based data means that you have to be careful not to destroy the data's character encoding by enforcing a default character encoding upon the bytes. If possible, adding such data using an InputStream is to be preferred.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    reader - A Reader from which RDF data can be read.
    
    baseURI - The base URI to resolve any relative URIs that are in the data against.
    
    dataFormat - The serialization format of the data.
    
    contexts - The contexts to add the data to. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
    
    Throws:
    
    IOException - If an I/O error occurred while reading from the reader.
    
    RDFParseException - If an error was found while parsing the RDF data.
    
    RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
  - add
```
public void add(Iterable<? extends Statement> statements,
                Resource... contexts)
         throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds the supplied statements to this repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    statements - The statements that should be added.
    
    contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, each statement is added to any context specified in the statement, or if the statement contains no context, it is added without context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself. ignored.
    
    Throws:
    
    RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
  - add
```
public <E extends Exception> void add(Iteration<? extends Statement,E> statements,
                                      Resource... contexts)
                               throws RepositoryException,
                                      E extends Exception
```
    Description copied from interface: RepositoryConnection
    
    Adds the supplied statements to this repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    statements - The statements to add. In case the iteration is a CloseableIteration, it will be closed before this method returns.
    
    contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, each statement is added to any context specified in the statement, or if the statement contains no context, it is added without context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself. ignored.
    
    Throws:
    
    RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
    
    E extends Exception
  - add
```
public void add(Statement st,
                Resource... contexts)
         throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds the supplied statement to this repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    st - The statement to add.
    
    contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the statement is added to any context specified in each statement, or if the statement contains no context, it is added without context. If one or more contexts are specified the statement is added to these contexts, ignoring any context information in the statement itself.
    
    Throws:
    
    RepositoryException - If the statement could not be added to the repository, for example because the repository is not writable.
  - add
```
public void add(Resource subject,
                URI predicate,
                Value object,
                Resource... contexts)
         throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
    
    Specified by:
    
    add in interface RepositoryConnection
    
    Parameters:
    
    subject - The statement's subject.
    
    predicate - The statement's predicate.
    
    object - The statement's object.
    
    contexts - The contexts to add the data to. Note that this parameter is a vararg and as such is optional. If no contexts are specified, the data is added to any context specified in the actual data file, or if the data contains no context, it is added without context. If one or more contexts are specified the data is added to these contexts, ignoring any context information in the data itself.
    
    Throws:
    
    RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
  - remove
```
public void remove(Iterable<? extends Statement> statements,
                   Resource... contexts)
            throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Removes the supplied statements from the specified contexts in this repository.
    
    Specified by:
    
    remove in interface RepositoryConnection
    
    Parameters:
    
    statements - The statements that should be added.
    
    contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
    
    Throws:
    
    RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
  - remove
```
public <E extends Exception> void remove(Iteration<? extends Statement,E> statements,
                                         Resource... contexts)
                                  throws RepositoryException,
                                         E extends Exception
```
    Description copied from interface: RepositoryConnection
    
    Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
    
    Specified by:
    
    remove in interface RepositoryConnection
    
    Parameters:
    
    statements - The statements to remove. In case the iteration is a CloseableIteration, it will be closed before this method returns.
    
    contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
    
    Throws:
    
    RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.
    
    E extends Exception
  - remove
```
public void remove(Statement st,
                   Resource... contexts)
            throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Removes the supplied statement from the specified contexts in the repository.
    
    Specified by:
    
    remove in interface RepositoryConnection
    
    Parameters:
    
    st - The statement to remove.
    
    contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the contexts associated with the statement itself, and if no context is associated with the statement, on the entire repository.
    
    Throws:
    
    RepositoryException - If the statement could not be removed from the repository, for example because the repository is not writable.
  - remove
```
public void remove(Resource subject,
                   URI predicate,
                   Value object,
                   Resource... contexts)
            throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
    
    Specified by:
    
    remove in interface RepositoryConnection
    
    Parameters:
    
    subject - The statement's subject, or null for a wildcard.
    
    predicate - The statement's predicate, or null for a wildcard.
    
    object - The statement's object, or null for a wildcard.
    
    contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
    
    Throws:
    
    RepositoryException - If the statement(s) could not be removed from the repository, for example because the repository is not writable.
  - clear
```
public void clear(Resource... contexts)
           throws RepositoryException
```
    Description copied from interface: RepositoryConnection
    
    Removes all statements from a specific contexts in the repository.
    
    Specified by:
    
    clear in interface RepositoryConnection
    
    Parameters:
    
    contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
    
    Throws:
    
    RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.
  - addWithoutCommit
```
protected void addWithoutCommit(Statement st,
                                Resource... contexts)
                         throws RepositoryException
```
    Throws:
    
    RepositoryException
  - addWithoutCommit
```
protected abstract void addWithoutCommit(Resource subject,
                                         URI predicate,
                                         Value object,
                                         Resource... contexts)
                                  throws RepositoryException
```
    Throws:
    
    RepositoryException
  - removeWithoutCommit
```
protected void removeWithoutCommit(Statement st,
                                   Resource... contexts)
                            throws RepositoryException
```
    Throws:
    
    RepositoryException
  - removeWithoutCommit
```
protected abstract void removeWithoutCommit(Resource subject,
                                            URI predicate,
                                            Value object,
                                            Resource... contexts)
                                     throws RepositoryException
```
    Throws:
    
    RepositoryException

Class RepositoryConnectionBase

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.openrdf.repository.RepositoryConnection

Field Detail

logger

Constructor Detail

RepositoryConnectionBase

Method Detail

setParserConfig

getParserConfig

getRepository

getValueFactory

isOpen

close

prepareQuery

prepareTupleQuery

prepareGraphQuery

prepareBooleanQuery

prepareUpdate

hasStatement

hasStatement

isEmpty

export

setAutoCommit

isAutoCommit

add

add

add

startLocalTransaction

conditionalCommit

conditionalRollback

add

add

add

add

add

remove

remove

remove

remove

clear

addWithoutCommit

addWithoutCommit

removeWithoutCommit

removeWithoutCommit