virtuoso.rdf4j.driver

Class VirtuosoRepositoryConnection

java.lang.Object

virtuoso.rdf4j.driver.VirtuosoRepositoryConnection

All Implemented Interfaces:

java.lang.AutoCloseable, org.eclipse.rdf4j.repository.RepositoryConnection

public class VirtuosoRepositoryConnection
extends java.lang.Object
implements org.eclipse.rdf4j.repository.RepositoryConnection

Main interface for updating data in and performing queries on a Sesame repository. By default, a RepositoryConnection is in autoCommit mode, meaning that each operation corresponds to a single transaction on the underlying store. autoCommit can be switched off in which case it is up to the user to handle transaction commit/rollback. Note that care should be taking to always properly close a RepositoryConnection after one is finished with it, to free up resources and avoid unnecessary locks.

Several methods take a vararg argument that optionally specifies a (set of) context(s) on which the method should operate. Note that a vararg parameter is optional, it can be completely left out of the method call, in which case a method either operates on a provided statements context (if one of the method parameters is a statement or collection of statements), or operates on the repository as a whole, completely ignoring context. A vararg argument may also be 'null' (cast to Resource) meaning that the method operates on those statements which have no associated context only.

Examples:

 // Ex 1: this method retrieves all statements that appear in either context1 or context2, or both.
 RepositoryConnection.getStatements(null, null, null, true, context1, context2);

 // Ex 2: this method retrieves all statements that appear in the repository (regardless of context).
 RepositoryConnection.getStatements(null, null, null, true);

 // Ex 3: this method retrieves all statements that have no associated context in the repository.
 // Observe that this is not equivalent to the previous method call.
 RepositoryConnection.getStatements(null, null, null, true, (Resource)null);

 // Ex 4: this method adds a statement to the store. If the statement object itself has
 // a context (i.e. statement.getContext() != null) the statement is added to that context. Otherwise,
 // it is added without any associated context.
 RepositoryConnection.add(statement);

 // Ex 5: this method adds a statement to context1 in the store. It completely ignores any
 // context the statement itself has.
 RepositoryConnection.add(statement, context1);
 

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	VirtuosoRepositoryConnection.CloseableIterationBase<E,X extends java.lang.Exception> protected void verifyTxnActive() throws StoreException { if (isAutoCommit()) { throw new RepositoryException("Connection does not have an active transaction"); } }
class	VirtuosoRepositoryConnection.CloseableIterationBindingSet
class	VirtuosoRepositoryConnection.CloseableIterationGraphResult
class	VirtuosoRepositoryConnection.CloseableIterationStmt

Field Summary

Fields

Modifier and Type	Field and Description
protected VirtuosoRepository	repository

Constructor Summary

Constructors

Constructor and Description
VirtuosoRepositoryConnection(VirtuosoRepository repository, java.sql.Connection connection)

Method Summary

Modifier and Type	Method and Description
void	add(java.io.File file, java.lang.String baseURI, org.eclipse.rdf4j.rio.RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts) Adds RDF data from the specified file to a specific contexts in the repository.
void	add(java.io.InputStream in, java.lang.String baseURI, org.eclipse.rdf4j.rio.RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts) Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
void	add(java.lang.Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts) Adds the supplied statements to this repository, optionally to one or more named contexts.
<E extends java.lang.Exception> void	add(org.eclipse.rdf4j.common.iteration.Iteration<? extends org.eclipse.rdf4j.model.Statement,E> statements, org.eclipse.rdf4j.model.Resource... contexts) Adds the supplied statements to this repository, optionally to one or more named contexts.
void	add(java.io.Reader reader, java.lang.String baseURI, org.eclipse.rdf4j.rio.RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts) Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
void	add(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts) Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
void	add(org.eclipse.rdf4j.model.Statement statement, org.eclipse.rdf4j.model.Resource... contexts) Adds the supplied statement to this repository, optionally to one or more named contexts.
void	add(java.net.URL url, java.lang.String baseURI, org.eclipse.rdf4j.rio.RDFFormat dataFormat, org.eclipse.rdf4j.model.Resource... contexts) Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
void	addQuad(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource context)
void	begin() Begins a transaction requiring commit() or rollback() to be called to end the transaction.
void	begin(org.eclipse.rdf4j.IsolationLevel level) Begins a new transaction with the supplied IsolationLevel, requiring commit() or rollback() to be called to end the transaction.
void	clear(org.eclipse.rdf4j.model.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 all updates that have been performed as part of this connection sofar.
protected <E> org.eclipse.rdf4j.repository.RepositoryResult<E>	createRepositoryResult(java.lang.Iterable<? extends E> elements) Creates a RepositoryResult for the supplied element set.
protected boolean	executeSPARQLForBooleanResult(java.lang.String baseURI, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
protected org.eclipse.rdf4j.query.GraphQueryResult	executeSPARQLForGraphResult(java.lang.String baseURI, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
protected void	executeSPARQLForHandler(java.lang.String baseURI, org.eclipse.rdf4j.rio.RDFHandler tqrh, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
protected void	executeSPARQLForHandler(java.lang.String baseURI, org.eclipse.rdf4j.query.TupleQueryResultHandler tqrh, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
protected org.eclipse.rdf4j.query.TupleQueryResult	executeSPARQLForTupleResult(java.lang.String baseURI, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
int	executeSPARUL(java.lang.String query) Execute SPARUL query on this repository.
protected void	executeSPARUL(java.lang.String baseURI, java.lang.String query, org.eclipse.rdf4j.query.Dataset dataset, boolean includeInferred, org.eclipse.rdf4j.query.BindingSet bindings, int maxQueryTime)
void	export(org.eclipse.rdf4j.rio.RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts) Exports all explicit statements in the specified contexts to the supplied RDFHandler.
void	exportStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.rio.RDFHandler handler, org.eclipse.rdf4j.model.Resource... contexts) Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.
org.eclipse.rdf4j.repository.RepositoryResult<org.eclipse.rdf4j.model.Resource>	getContextIDs() Gets all resources that are used as content identifiers.
org.eclipse.rdf4j.IsolationLevel	getIsolationLevel() Retrieves the current transaction isolation level of the connection.
java.lang.String	getNamespace(java.lang.String prefix) Gets the namespace that is associated with the specified prefix, if any.
org.eclipse.rdf4j.repository.RepositoryResult<org.eclipse.rdf4j.model.Namespace>	getNamespaces() Gets all declared namespaces as a RepositoryResult of Namespace objects.
org.eclipse.rdf4j.rio.ParserConfig	getParserConfig() Returns the parser configuration this connection uses for Rio-based operations.
java.sql.Connection	getQuadStoreConnection() Get Reposetory Connection.
org.eclipse.rdf4j.repository.Repository	getRepository() Returns the Repository object to which this connection belongs.
org.eclipse.rdf4j.repository.RepositoryResult<org.eclipse.rdf4j.model.Statement>	getStatements(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts) Gets all statements with a specific subject, predicate and/or object from the repository.
org.eclipse.rdf4j.model.ValueFactory	getValueFactory() Gets a ValueFactory for this RepositoryConnection.
boolean	hasStatement(org.eclipse.rdf4j.model.Resource subj, org.eclipse.rdf4j.model.IRI pred, org.eclipse.rdf4j.model.Value obj, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts) Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
boolean	hasStatement(org.eclipse.rdf4j.model.Statement st, boolean includeInferred, org.eclipse.rdf4j.model.Resource... contexts) Checks whether the repository contains the specified statement, optionally in the specified contexts.
boolean	isActive() Indicates if a transaction is currently active on the connection.
boolean	isAutoCommit() Deprecated. since 2.7.0. Use isActive() instead.
boolean	isEmpty() Returns true if this repository does not contain any (explicit) statements.
boolean	isOpen() Checks whether this connection is open.
org.eclipse.rdf4j.query.BooleanQuery	prepareBooleanQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query) Prepares true/false queries.
org.eclipse.rdf4j.query.BooleanQuery	prepareBooleanQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query, java.lang.String baseURI) Prepares true/false queries.
org.eclipse.rdf4j.query.GraphQuery	prepareGraphQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query) Prepares queries that produce RDF graphs.
org.eclipse.rdf4j.query.GraphQuery	prepareGraphQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query, java.lang.String baseURI) Prepares queries that produce RDF graphs.
org.eclipse.rdf4j.query.Query	prepareQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query) Prepares a query for evaluation on this repository (optional operation).
org.eclipse.rdf4j.query.Query	prepareQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query, java.lang.String baseURI) Prepares a query for evaluation on this repository (optional operation).
org.eclipse.rdf4j.query.TupleQuery	prepareTupleQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query) Prepares a query that produces sets of value tuples.
org.eclipse.rdf4j.query.TupleQuery	prepareTupleQuery(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query, java.lang.String baseURI) Prepares a query that produces sets of value tuples.
org.eclipse.rdf4j.query.Update	prepareUpdate(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query)
org.eclipse.rdf4j.query.Update	prepareUpdate(org.eclipse.rdf4j.query.QueryLanguage ql, java.lang.String query, java.lang.String baseURI)
void	remove(java.lang.Iterable<? extends org.eclipse.rdf4j.model.Statement> statements, org.eclipse.rdf4j.model.Resource... contexts) Removes the supplied statements from the specified contexts in this repository.
<E extends java.lang.Exception> void	remove(org.eclipse.rdf4j.common.iteration.Iteration<? extends org.eclipse.rdf4j.model.Statement,E> statements, org.eclipse.rdf4j.model.Resource... contexts) Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
void	remove(org.eclipse.rdf4j.model.Resource subject, org.eclipse.rdf4j.model.IRI predicate, org.eclipse.rdf4j.model.Value object, org.eclipse.rdf4j.model.Resource... contexts) Removes the statement(s) with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
void	remove(org.eclipse.rdf4j.model.Statement statement, org.eclipse.rdf4j.model.Resource... contexts) Removes the supplied statement from the specified contexts in the repository.
void	removeNamespace(java.lang.String prefix) Removes a namespace declaration by removing the association between a prefix and a namespace name.
void	rollback() Rolls back all updates that have been performed as part of this connection sofar.
void	setAutoCommit(boolean autoCommit) Deprecated. since 2.7.0. Use begin() instead.
void	setIsolationLevel(org.eclipse.rdf4j.IsolationLevel level) Sets the transaction isolation level for the next transaction(s) on this connection.
void	setNamespace(java.lang.String prefix, java.lang.String name) Sets the prefix for a namespace.
void	setParserConfig(org.eclipse.rdf4j.rio.ParserConfig parserConfig) Set the parser configuration this connection should use for RDFParser-based operations.
void	setQuadStoreConnection(java.sql.Connection quadStoreConnection) Set Repository Connection.
long	size(org.eclipse.rdf4j.model.Resource... contexts) Returns the number of (explicit) statements that are in the specified contexts in this repository.
protected void	verifyNotTxnActive(java.lang.String msg)

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, getStatements, getStatements, hasStatement, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, remove

Field Detail

repository

protected VirtuosoRepository repository

Constructor Detail

VirtuosoRepositoryConnection

public VirtuosoRepositoryConnection(VirtuosoRepository repository,
                                    java.sql.Connection connection)
                             throws org.eclipse.rdf4j.repository.RepositoryException

Throws:

org.eclipse.rdf4j.repository.RepositoryException

Method Detail

getRepository

public org.eclipse.rdf4j.repository.Repository getRepository()

Returns the Repository object to which this connection belongs.

Specified by:

getRepository in interface org.eclipse.rdf4j.repository.RepositoryConnection

setParserConfig

public void setParserConfig(org.eclipse.rdf4j.rio.ParserConfig parserConfig)

Set the parser configuration this connection should use for RDFParser-based operations.

Specified by:

setParserConfig in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

parserConfig - a Rio RDF Parser configuration.

getParserConfig

public org.eclipse.rdf4j.rio.ParserConfig getParserConfig()

Returns the parser configuration this connection uses for Rio-based operations.

Specified by:

getParserConfig in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

a Rio RDF parser configuration.

getValueFactory

public org.eclipse.rdf4j.model.ValueFactory getValueFactory()

Gets a ValueFactory for this RepositoryConnection.

Specified by:

getValueFactory in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

A repository-specific ValueFactory.

isOpen

public boolean isOpen()
               throws org.eclipse.rdf4j.repository.RepositoryException

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 org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException

See Also:

close()

close

public void close()
           throws org.eclipse.rdf4j.repository.RepositoryException

Closes the connection, freeing resources. If the connection is not in autoCommit mode, all non-committed operations will be lost.

Specified by:

close in interface java.lang.AutoCloseable

Specified by:

close in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the connection could not be closed.

prepareQuery

public org.eclipse.rdf4j.query.Query prepareQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                  java.lang.String query)
                                           throws org.eclipse.rdf4j.repository.RepositoryException,
                                                  org.eclipse.rdf4j.query.MalformedQueryException

Prepares a query for evaluation on this repository (optional operation). In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareQuery(QueryLanguage, String, String) instead.

Specified by:

prepareQuery in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

java.lang.UnsupportedOperationException - If the prepareQuery method is not supported by this repository.

org.eclipse.rdf4j.repository.RepositoryException

prepareQuery

public org.eclipse.rdf4j.query.Query prepareQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                  java.lang.String query,
                                                  java.lang.String baseURI)
                                           throws org.eclipse.rdf4j.repository.RepositoryException,
                                                  org.eclipse.rdf4j.query.MalformedQueryException

Prepares a query for evaluation on this repository (optional operation).

Specified by:

prepareQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.

Returns:

A query ready to be evaluated on this repository.

Throws:

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

java.lang.UnsupportedOperationException - If the prepareQuery method is not supported by this repository.

org.eclipse.rdf4j.repository.RepositoryException

prepareTupleQuery

public org.eclipse.rdf4j.query.TupleQuery prepareTupleQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                            java.lang.String query)
                                                     throws org.eclipse.rdf4j.repository.RepositoryException,
                                                            org.eclipse.rdf4j.query.MalformedQueryException

Prepares a query that produces sets of value tuples. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareTupleQuery(QueryLanguage, String, String) instead.

Specified by:

prepareTupleQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a tuple query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareTupleQuery

public org.eclipse.rdf4j.query.TupleQuery prepareTupleQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                            java.lang.String query,
                                                            java.lang.String baseURI)
                                                     throws org.eclipse.rdf4j.repository.RepositoryException,
                                                            org.eclipse.rdf4j.query.MalformedQueryException

Prepares a query that produces sets of value tuples.

Specified by:

prepareTupleQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a tuple query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareGraphQuery

public org.eclipse.rdf4j.query.GraphQuery prepareGraphQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                            java.lang.String query)
                                                     throws org.eclipse.rdf4j.repository.RepositoryException,
                                                            org.eclipse.rdf4j.query.MalformedQueryException

Prepares queries that produce RDF graphs. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareGraphQuery(QueryLanguage, String, String) instead.

Specified by:

prepareGraphQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a graph query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareGraphQuery

public org.eclipse.rdf4j.query.GraphQuery prepareGraphQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                            java.lang.String query,
                                                            java.lang.String baseURI)
                                                     throws org.eclipse.rdf4j.repository.RepositoryException,
                                                            org.eclipse.rdf4j.query.MalformedQueryException

Prepares queries that produce RDF graphs.

Specified by:

prepareGraphQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a graph query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareBooleanQuery

public org.eclipse.rdf4j.query.BooleanQuery prepareBooleanQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                                java.lang.String query)
                                                         throws org.eclipse.rdf4j.repository.RepositoryException,
                                                                org.eclipse.rdf4j.query.MalformedQueryException

Prepares true/false queries. In case the query contains relative URIs that need to be resolved against an external base URI, one should use prepareBooleanQuery(QueryLanguage, String, String) instead.

Specified by:

prepareBooleanQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a boolean query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareBooleanQuery

public org.eclipse.rdf4j.query.BooleanQuery prepareBooleanQuery(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                                java.lang.String query,
                                                                java.lang.String baseURI)
                                                         throws org.eclipse.rdf4j.repository.RepositoryException,
                                                                org.eclipse.rdf4j.query.MalformedQueryException

Prepares true/false queries.

Specified by:

prepareBooleanQuery in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

ql - The query language in which the query is formulated.

query - The query string.

baseURI - The base URI to resolve any relative URIs that are in the query against, can be null if the query does not contain any relative URIs.

Throws:

java.lang.IllegalArgumentException - If the supplied query is not a boolean query.

org.eclipse.rdf4j.query.MalformedQueryException - If the supplied query is malformed.

org.eclipse.rdf4j.query.UnsupportedQueryLanguageException - If the supplied query language is not supported.

org.eclipse.rdf4j.repository.RepositoryException

prepareUpdate

public org.eclipse.rdf4j.query.Update prepareUpdate(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                    java.lang.String query)
                                             throws org.eclipse.rdf4j.repository.RepositoryException,
                                                    org.eclipse.rdf4j.query.MalformedQueryException

Specified by:

prepareUpdate in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException

org.eclipse.rdf4j.query.MalformedQueryException

prepareUpdate

public org.eclipse.rdf4j.query.Update prepareUpdate(org.eclipse.rdf4j.query.QueryLanguage ql,
                                                    java.lang.String query,
                                                    java.lang.String baseURI)
                                             throws org.eclipse.rdf4j.repository.RepositoryException,
                                                    org.eclipse.rdf4j.query.MalformedQueryException

Specified by:

prepareUpdate in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException

org.eclipse.rdf4j.query.MalformedQueryException

getContextIDs

public org.eclipse.rdf4j.repository.RepositoryResult<org.eclipse.rdf4j.model.Resource> getContextIDs()
                                                                                              throws org.eclipse.rdf4j.repository.RepositoryException

Gets all resources that are used as content identifiers. Care should be taken that the returned RepositoryResult is closed to free any resources that it keeps hold of.

Specified by:

getContextIDs in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

a RepositoryResult object containing Resources that are used as context identifiers.

Throws:

org.eclipse.rdf4j.repository.RepositoryException

getStatements

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

Gets all statements with a specific subject, predicate and/or object from the repository. The result is optionally restricted to the specified set of named contexts.

Specified by:

getStatements in interface org.eclipse.rdf4j.repository.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 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 Statements and optionally throwing a RepositoryException when an error when a problem occurs during retrieval.

Throws:

org.eclipse.rdf4j.repository.RepositoryException

hasStatement

public boolean hasStatement(org.eclipse.rdf4j.model.Resource subj,
                            org.eclipse.rdf4j.model.IRI pred,
                            org.eclipse.rdf4j.model.Value obj,
                            boolean includeInferred,
                            org.eclipse.rdf4j.model.Resource... contexts)
                     throws org.eclipse.rdf4j.repository.RepositoryException

Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.

Specified by:

hasStatement in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException

hasStatement

public boolean hasStatement(org.eclipse.rdf4j.model.Statement st,
                            boolean includeInferred,
                            org.eclipse.rdf4j.model.Resource... contexts)
                     throws org.eclipse.rdf4j.repository.RepositoryException

Checks whether the repository contains the specified statement, optionally in the specified contexts.

Specified by:

hasStatement in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException

exportStatements

public void exportStatements(org.eclipse.rdf4j.model.Resource subj,
                             org.eclipse.rdf4j.model.IRI pred,
                             org.eclipse.rdf4j.model.Value obj,
                             boolean includeInferred,
                             org.eclipse.rdf4j.rio.RDFHandler handler,
                             org.eclipse.rdf4j.model.Resource... contexts)
                      throws org.eclipse.rdf4j.repository.RepositoryException,
                             org.eclipse.rdf4j.rio.RDFHandlerException

Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts.

Specified by:

exportStatements in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.rio.RDFHandlerException - If the handler encounters an unrecoverable error.

org.eclipse.rdf4j.repository.RepositoryException

export

public void export(org.eclipse.rdf4j.rio.RDFHandler handler,
                   org.eclipse.rdf4j.model.Resource... contexts)
            throws org.eclipse.rdf4j.repository.RepositoryException,
                   org.eclipse.rdf4j.rio.RDFHandlerException

Exports all explicit statements in the specified contexts to the supplied RDFHandler.

Specified by:

export in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.rio.RDFHandlerException - If the handler encounters an unrecoverable error.

org.eclipse.rdf4j.repository.RepositoryException

size

public long size(org.eclipse.rdf4j.model.Resource... contexts)
          throws org.eclipse.rdf4j.repository.RepositoryException

Returns the number of (explicit) statements that are in the specified contexts in this repository.

Specified by:

size in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException

isEmpty

public boolean isEmpty()
                throws org.eclipse.rdf4j.repository.RepositoryException

Returns true if this repository does not contain any (explicit) statements.

Specified by:

isEmpty in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

true if this repository is empty, false otherwise.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the repository could not be checked to be empty.

setAutoCommit

@Deprecated
public void setAutoCommit(boolean autoCommit)
                               throws org.eclipse.rdf4j.repository.RepositoryException

Deprecated. since 2.7.0. Use begin() instead.

Enables or disables auto-commit mode for the connection. If a connection is in auto-commit mode, then all updates will be executed and committed as individual transactions. Otherwise, the updates are grouped into transactions that are terminated by a call to either commit() or rollback(). By default, new connections are in auto-commit mode.

NOTE: If this connection is switched to auto-commit mode during a transaction, the transaction is committed.

Specified by:

setAutoCommit in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - In case the mode switch failed, for example because a currently active transaction failed to commit.

See Also:

commit()

isAutoCommit

@Deprecated
public boolean isAutoCommit()
                                 throws org.eclipse.rdf4j.repository.RepositoryException

Deprecated. since 2.7.0. Use isActive() instead.

Checks whether the connection is in auto-commit mode.

Specified by:

isAutoCommit in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException

See Also:

setAutoCommit(boolean)

isActive

public boolean isActive()
                 throws org.eclipse.rdf4j.repository.RepositoryException

Indicates if a transaction is currently active on the connection. A transaction is active if begin() has been called, and becomes inactive after commit() or rollback() has been called.

Specified by:

isActive in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

true iff a transaction is active, false iff no transaction is active.

Throws:

org.eclipse.rdf4j.repository.UnknownTransactionStateException - if the transaction state can not be determined. This can happen for instance when communication with a repository fails or times out.

org.eclipse.rdf4j.repository.RepositoryException

Since:

2.7.0

setIsolationLevel

public void setIsolationLevel(org.eclipse.rdf4j.IsolationLevel level)
                       throws java.lang.IllegalStateException

Sets the transaction isolation level for the next transaction(s) on this connection. If the level is set to a value that is not supported by the underlying repository, this method will still succeed but a subsequent call to begin() will result in an exception.

Specified by:

setIsolationLevel in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

level - the transaction isolation level to set.

Throws:

java.lang.IllegalStateException - if the method is called while a transaction is already active.

Since:

2.8.0

getIsolationLevel

public org.eclipse.rdf4j.IsolationLevel getIsolationLevel()

Retrieves the current transaction isolation level of the connection.

Specified by:

getIsolationLevel in interface org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

the current transaction isolation level.

Since:

2.8.0

begin

public void begin()
           throws org.eclipse.rdf4j.repository.RepositoryException

Begins a transaction requiring commit() or rollback() to be called to end the transaction.

Specified by:

begin in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the connection could not start a transaction.

Since:

2.7.0

See Also:

isActive(), commit(), rollback()

begin

public void begin(org.eclipse.rdf4j.IsolationLevel level)
           throws org.eclipse.rdf4j.repository.RepositoryException

Begins a new transaction with the supplied IsolationLevel, requiring commit() or rollback() to be called to end the transaction.

Specified by:

begin in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

level - The IsolationLevel at which this transaction will operate. If set to null the default isolation level of the underlying store will be used. If the specified isolation level is not supported by the underlying store, it will attempt to use a supported compatible level instead.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the connection could not start the transaction. Possible reasons this may happen are:

• a transaction is already active on the current connection.
• the specified IsolationLevel is not supported by the store, and no compatible level could be found.

Since:

2.8.0

See Also:

begin(), isActive(), commit(), rollback(), setIsolationLevel(IsolationLevel)

commit

public void commit()
            throws org.eclipse.rdf4j.repository.RepositoryException

Commits all updates that have been performed as part of this connection sofar.

Specified by:

commit in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the connection could not be committed.

rollback

public void rollback()
              throws org.eclipse.rdf4j.repository.RepositoryException

Rolls back all updates that have been performed as part of this connection sofar.

Specified by:

rollback in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the connection could not be rolled back.

add

public void add(java.io.InputStream in,
                java.lang.String baseURI,
                org.eclipse.rdf4j.rio.RDFFormat dataFormat,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws java.io.IOException,
                org.eclipse.rdf4j.rio.RDFParseException,
                org.eclipse.rdf4j.repository.RepositoryException

Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.

Specified by:

add in interface org.eclipse.rdf4j.repository.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:

java.io.IOException - If an I/O error occurred while reading from the input stream.

org.eclipse.rdf4j.rio.UnsupportedRDFormatException - If no parser is available for the specified RDF format.

org.eclipse.rdf4j.rio.RDFParseException - If an error was found while parsing the RDF data.

org.eclipse.rdf4j.repository.RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

public void add(java.io.Reader reader,
                java.lang.String baseURI,
                org.eclipse.rdf4j.rio.RDFFormat dataFormat,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws java.io.IOException,
                org.eclipse.rdf4j.rio.RDFParseException,
                org.eclipse.rdf4j.repository.RepositoryException

Adds RDF data from a Reader to the repository, optionally to one or more named contexts. Note: using a Reader to upload byte-based data means that you have to be careful not to destroy the data's character encoding by enforcing a default character encoding upon the bytes. If possible, adding such data using an InputStream is to be preferred.

Specified by:

add in interface org.eclipse.rdf4j.repository.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:

java.io.IOException - If an I/O error occurred while reading from the reader.

org.eclipse.rdf4j.rio.UnsupportedRDFormatException - If no parser is available for the specified RDF format.

org.eclipse.rdf4j.rio.RDFParseException - If an error was found while parsing the RDF data.

org.eclipse.rdf4j.repository.RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

public void add(java.net.URL url,
                java.lang.String baseURI,
                org.eclipse.rdf4j.rio.RDFFormat dataFormat,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws java.io.IOException,
                org.eclipse.rdf4j.rio.RDFParseException,
                org.eclipse.rdf4j.repository.RepositoryException

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 org.eclipse.rdf4j.repository.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.

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:

java.io.IOException - If an I/O error occurred while reading from the URL.

org.eclipse.rdf4j.rio.UnsupportedRDFormatException - If no parser is available for the specified RDF format.

org.eclipse.rdf4j.rio.RDFParseException - If an error was found while parsing the RDF data.

org.eclipse.rdf4j.repository.RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

public void add(java.io.File file,
                java.lang.String baseURI,
                org.eclipse.rdf4j.rio.RDFFormat dataFormat,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws java.io.IOException,
                org.eclipse.rdf4j.rio.RDFParseException,
                org.eclipse.rdf4j.repository.RepositoryException

Adds RDF data from the specified file to a specific contexts in the repository.

Specified by:

add in interface org.eclipse.rdf4j.repository.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:

java.io.IOException - If an I/O error occurred while reading from the file.

org.eclipse.rdf4j.rio.UnsupportedRDFormatException - If no parser is available for the specified RDF format.

org.eclipse.rdf4j.rio.RDFParseException - If an error was found while parsing the RDF data.

org.eclipse.rdf4j.repository.RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

add

public void add(org.eclipse.rdf4j.model.Resource subject,
                org.eclipse.rdf4j.model.IRI predicate,
                org.eclipse.rdf4j.model.Value object,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws org.eclipse.rdf4j.repository.RepositoryException

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 org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.

addQuad

public void addQuad(org.eclipse.rdf4j.model.Resource subject,
                    org.eclipse.rdf4j.model.IRI predicate,
                    org.eclipse.rdf4j.model.Value object,
                    org.eclipse.rdf4j.model.Resource context)
             throws org.eclipse.rdf4j.repository.RepositoryException

Throws:

org.eclipse.rdf4j.repository.RepositoryException

add

public void add(org.eclipse.rdf4j.model.Statement statement,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws org.eclipse.rdf4j.repository.RepositoryException

Adds the supplied statement to this repository, optionally to one or more named contexts.

Specified by:

add in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

statement - 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:

org.eclipse.rdf4j.repository.RepositoryException - If the statement could not be added to the repository, for example because the repository is not writable.

add

public void add(java.lang.Iterable<? extends org.eclipse.rdf4j.model.Statement> statements,
                org.eclipse.rdf4j.model.Resource... contexts)
         throws org.eclipse.rdf4j.repository.RepositoryException

Adds the supplied statements to this repository, optionally to one or more named contexts.

Specified by:

add in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.

add

public <E extends java.lang.Exception> void add(org.eclipse.rdf4j.common.iteration.Iteration<? extends org.eclipse.rdf4j.model.Statement,E> statements,
                                                org.eclipse.rdf4j.model.Resource... contexts)
                                         throws org.eclipse.rdf4j.repository.RepositoryException,
                                                E extends java.lang.Exception

Adds the supplied statements to this repository, optionally to one or more named contexts.

Specified by:

add in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

statements - The statements to add. In case the iterator 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:

org.eclipse.rdf4j.repository.RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.

E extends java.lang.Exception

remove

public void remove(org.eclipse.rdf4j.model.Resource subject,
                   org.eclipse.rdf4j.model.IRI predicate,
                   org.eclipse.rdf4j.model.Value object,
                   org.eclipse.rdf4j.model.Resource... contexts)
            throws org.eclipse.rdf4j.repository.RepositoryException

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 org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException - If the statement(s) could not be removed from the repository, for example because the repository is not writable.

remove

public void remove(org.eclipse.rdf4j.model.Statement statement,
                   org.eclipse.rdf4j.model.Resource... contexts)
            throws org.eclipse.rdf4j.repository.RepositoryException

Removes the supplied statement from the specified contexts in the repository.

Specified by:

remove in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

statement - 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:

org.eclipse.rdf4j.repository.RepositoryException - If the statement could not be removed from the repository, for example because the repository is not writable.

remove

public void remove(java.lang.Iterable<? extends org.eclipse.rdf4j.model.Statement> statements,
                   org.eclipse.rdf4j.model.Resource... contexts)
            throws org.eclipse.rdf4j.repository.RepositoryException

Removes the supplied statements from the specified contexts in this repository.

Specified by:

remove in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

statements - The statements that should be removed.

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:

org.eclipse.rdf4j.repository.RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.

remove

public <E extends java.lang.Exception> void remove(org.eclipse.rdf4j.common.iteration.Iteration<? extends org.eclipse.rdf4j.model.Statement,E> statements,
                                                   org.eclipse.rdf4j.model.Resource... contexts)
                                            throws org.eclipse.rdf4j.repository.RepositoryException,
                                                   E extends java.lang.Exception

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 org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

statements - The statements to remove. In case the iterator 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:

org.eclipse.rdf4j.repository.RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.

E extends java.lang.Exception

clear

public void clear(org.eclipse.rdf4j.model.Resource... contexts)
           throws org.eclipse.rdf4j.repository.RepositoryException

Removes all statements from a specific contexts in the repository.

Specified by:

clear in interface org.eclipse.rdf4j.repository.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:

org.eclipse.rdf4j.repository.RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.

getNamespaces

public org.eclipse.rdf4j.repository.RepositoryResult<org.eclipse.rdf4j.model.Namespace> getNamespaces()
                                                                                               throws org.eclipse.rdf4j.repository.RepositoryException

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 org.eclipse.rdf4j.repository.RepositoryConnection

Returns:

A RepositoryResult containing Namespace objects. Care should be taken to close the RepositoryResult after use.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the namespaces could not be read from the repository.

getNamespace

public java.lang.String getNamespace(java.lang.String prefix)
                              throws org.eclipse.rdf4j.repository.RepositoryException

Gets the namespace that is associated with the specified prefix, if any.

Specified by:

getNamespace in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

prefix - A namespace prefix.

Returns:

The namespace name that is associated with the specified prefix, or null if there is no such namespace.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the namespace could not be read from the repository.

setNamespace

public void setNamespace(java.lang.String prefix,
                         java.lang.String name)
                  throws org.eclipse.rdf4j.repository.RepositoryException

Sets the prefix for a namespace.

Specified by:

setNamespace in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

prefix - The new prefix.

name - The namespace name that the prefix maps to.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the namespace could not be set in the repository, for example because the repository is not writable.

removeNamespace

public void removeNamespace(java.lang.String prefix)
                     throws org.eclipse.rdf4j.repository.RepositoryException

Removes a namespace declaration by removing the association between a prefix and a namespace name.

Specified by:

removeNamespace in interface org.eclipse.rdf4j.repository.RepositoryConnection

Parameters:

prefix - The namespace prefix of which the assocation with a namespace name is to be removed.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the namespace prefix could not be removed.

clearNamespaces

public void clearNamespaces()
                     throws org.eclipse.rdf4j.repository.RepositoryException

Removes all namespace declarations from the repository.

Specified by:

clearNamespaces in interface org.eclipse.rdf4j.repository.RepositoryConnection

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the namespace declarations could not be removed.

executeSPARQLForTupleResult

protected org.eclipse.rdf4j.query.TupleQueryResult executeSPARQLForTupleResult(java.lang.String baseURI,
                                                                               java.lang.String query,
                                                                               org.eclipse.rdf4j.query.Dataset dataset,
                                                                               boolean includeInferred,
                                                                               org.eclipse.rdf4j.query.BindingSet bindings,
                                                                               int maxQueryTime)
                                                                        throws org.eclipse.rdf4j.query.QueryEvaluationException

Throws:

org.eclipse.rdf4j.query.QueryEvaluationException

executeSPARQLForGraphResult

protected org.eclipse.rdf4j.query.GraphQueryResult executeSPARQLForGraphResult(java.lang.String baseURI,
                                                                               java.lang.String query,
                                                                               org.eclipse.rdf4j.query.Dataset dataset,
                                                                               boolean includeInferred,
                                                                               org.eclipse.rdf4j.query.BindingSet bindings,
                                                                               int maxQueryTime)
                                                                        throws org.eclipse.rdf4j.query.QueryEvaluationException

Throws:

org.eclipse.rdf4j.query.QueryEvaluationException

executeSPARQLForBooleanResult

protected boolean executeSPARQLForBooleanResult(java.lang.String baseURI,
                                                java.lang.String query,
                                                org.eclipse.rdf4j.query.Dataset dataset,
                                                boolean includeInferred,
                                                org.eclipse.rdf4j.query.BindingSet bindings,
                                                int maxQueryTime)
                                         throws org.eclipse.rdf4j.query.QueryEvaluationException

Throws:

org.eclipse.rdf4j.query.QueryEvaluationException

executeSPARQLForHandler

protected void executeSPARQLForHandler(java.lang.String baseURI,
                                       org.eclipse.rdf4j.query.TupleQueryResultHandler tqrh,
                                       java.lang.String query,
                                       org.eclipse.rdf4j.query.Dataset dataset,
                                       boolean includeInferred,
                                       org.eclipse.rdf4j.query.BindingSet bindings,
                                       int maxQueryTime)
                                throws org.eclipse.rdf4j.query.QueryEvaluationException,
                                       org.eclipse.rdf4j.query.TupleQueryResultHandlerException

Throws:

org.eclipse.rdf4j.query.QueryEvaluationException

org.eclipse.rdf4j.query.TupleQueryResultHandlerException

executeSPARQLForHandler

protected void executeSPARQLForHandler(java.lang.String baseURI,
                                       org.eclipse.rdf4j.rio.RDFHandler tqrh,
                                       java.lang.String query,
                                       org.eclipse.rdf4j.query.Dataset dataset,
                                       boolean includeInferred,
                                       org.eclipse.rdf4j.query.BindingSet bindings,
                                       int maxQueryTime)
                                throws org.eclipse.rdf4j.query.QueryEvaluationException,
                                       org.eclipse.rdf4j.rio.RDFHandlerException

Throws:

org.eclipse.rdf4j.query.QueryEvaluationException

org.eclipse.rdf4j.rio.RDFHandlerException

executeSPARUL

protected void executeSPARUL(java.lang.String baseURI,
                             java.lang.String query,
                             org.eclipse.rdf4j.query.Dataset dataset,
                             boolean includeInferred,
                             org.eclipse.rdf4j.query.BindingSet bindings,
                             int maxQueryTime)
                      throws org.eclipse.rdf4j.query.UpdateExecutionException

Throws:

org.eclipse.rdf4j.query.UpdateExecutionException

executeSPARUL

public int executeSPARUL(java.lang.String query)
                  throws org.eclipse.rdf4j.repository.RepositoryException

Execute SPARUL query on this repository.

Parameters:

query - The query string.

Returns:

A rowUpdateCount.

Throws:

org.eclipse.rdf4j.repository.RepositoryException - If the prepareQuery method is not supported by this repository.

getQuadStoreConnection

public java.sql.Connection getQuadStoreConnection()

Get Reposetory Connection.

Returns:

Repository Connection

setQuadStoreConnection

public void setQuadStoreConnection(java.sql.Connection quadStoreConnection)

Set Repository Connection.

Parameters:

quadStoreConnection - The Repository Connection.

createRepositoryResult

protected <E> org.eclipse.rdf4j.repository.RepositoryResult<E> createRepositoryResult(java.lang.Iterable<? extends E> elements)

Creates a RepositoryResult for the supplied element set.

verifyNotTxnActive

protected void verifyNotTxnActive(java.lang.String msg)
                           throws org.eclipse.rdf4j.repository.RepositoryException

Throws:

org.eclipse.rdf4j.repository.RepositoryException