eu.fbk.knowledgestore.triplestore

Class ForwardingTripleTransaction

java.lang.Object

com.google.common.collect.ForwardingObject

eu.fbk.knowledgestore.triplestore.ForwardingTripleTransaction

All Implemented Interfaces:

TripleTransaction

public abstract class ForwardingTripleTransaction
extends ForwardingObject
implements TripleTransaction

A TripleTransaction that forwards all its method calls to another TripleTransaction.

This class provides a starting point for implementing the decorator pattern on top of the TripleTransaction interface. Subclasses must implement method delegate() and override the methods of TripleTransaction they want to decorate.

Constructor Summary

Constructors

Constructor and Description
ForwardingTripleTransaction()

Method Summary

Modifier and Type	Method and Description
void	add(Iterable<? extends org.openrdf.model.Statement> statements) Adds all the RDF statements in the Iterable specified to the triple store.
protected abstract TripleTransaction	delegate()
void	end(boolean commit) Ends the transaction, either committing or rolling back its changes (if any).
info.aduna.iteration.CloseableIteration<? extends org.openrdf.model.Statement,? extends Exception>	get(org.openrdf.model.Resource subject, org.openrdf.model.URI predicate, org.openrdf.model.Value object, org.openrdf.model.Resource context) Returns a Sesame CloseableIteration over all the RDF statements matching the (optional) subject, predicate, object, context supplied.
void	infer(Handler<? super org.openrdf.model.Statement> handler) Performs inference, materializing the logical closure of the RDF statements contained in the triple store.
info.aduna.iteration.CloseableIteration<org.openrdf.query.BindingSet,org.openrdf.query.QueryEvaluationException>	query(SelectQuery query, org.openrdf.query.BindingSet bindings, Long timeout) Evaluates the supplied SPARQL SELECT query, returning a Sesame CloseableIteration over its solutions.
void	remove(Iterable<? extends org.openrdf.model.Statement> statements) Removes all the RDF statements in the Iterable specified from the triple store.

Methods inherited from class com.google.common.collect.ForwardingObject

toString

Methods inherited from class java.lang.Object

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

Constructor Detail

ForwardingTripleTransaction

public ForwardingTripleTransaction()

Method Detail

delegate

protected abstract TripleTransaction delegate()

Specified by:

delegate in class ForwardingObject

get

public info.aduna.iteration.CloseableIteration<? extends org.openrdf.model.Statement,? extends Exception> get(@Nullable
                                                                                                              org.openrdf.model.Resource subject,
                                                                                                              @Nullable
                                                                                                              org.openrdf.model.URI predicate,
                                                                                                              @Nullable
                                                                                                              org.openrdf.model.Value object,
                                                                                                              @Nullable
                                                                                                              org.openrdf.model.Resource context)
                                                                                                       throws IOException,
                                                                                                              IllegalStateException

Description copied from interface: TripleTransaction

Returns a Sesame CloseableIteration over all the RDF statements matching the (optional) subject, predicate, object, context supplied. Null values are used as wildcard. Implementations are designed to perform high throughput statement extraction (likely more efficient than doing a SPARQL query).

Specified by:

get in interface TripleTransaction

Parameters:

subject - the subject to match, null to match any subject

predicate - the predicate to match, null to match any predicate

object - the object to match, null to match any object

context - the context to match, null to match any context

Returns:

an iteration over matching RDF statements

Throws:

IOException - in case some IO error occurs

IllegalStateException - if the TripleTransaction has been already ended

query

public info.aduna.iteration.CloseableIteration<org.openrdf.query.BindingSet,org.openrdf.query.QueryEvaluationException> query(SelectQuery query,
                                                                                                                              @Nullable
                                                                                                                              org.openrdf.query.BindingSet bindings,
                                                                                                                              @Nullable
                                                                                                                              Long timeout)
                                                                                                                       throws IOException,
                                                                                                                              UnsupportedOperationException

Description copied from interface: TripleTransaction

Evaluates the supplied SPARQL SELECT query, returning a Sesame CloseableIteration over its solutions. The method accepts an optional BindingSet object, providing bindings for variables in the query; it can be used to instantiate parametric queries, similarly to PreparedStatements in JDBC.

Specified by:

query in interface TripleTransaction

Parameters:

query - the SPARQL SELECT query to evaluate

bindings - optional bindings for variables in the query;

timeout - optional timeout in milliseconds for the query

Returns:

an iteration over the results of the query

Throws:

IOException - in case some IO error occurs

UnsupportedOperationException - in case the query, while being valid according to SPARQL, uses a construct, function or feature that is not supported by the triple store implementation (refer to the implementation documentation for unsupported features)

infer

public void infer(@Nullable
                  Handler<? super org.openrdf.model.Statement> handler)
           throws IOException,
                  IllegalStateException

Description copied from interface: TripleTransaction

Performs inference, materializing the logical closure of the RDF statements contained in the triple store. The method accepts an optional Handler inferred statements can be notified to, allowing for their additional processing by external code.

Specified by:

infer in interface TripleTransaction

Parameters:

handler - an optional handler inferred RDF statements can be notified to

Throws:

IOException - in case some IO error occurs, with no guarantee that the TripleStore is left in the same state if was when the method was called; note that this exception may trigger a rollback on the caller side

IllegalStateException - if the TripleTransaction has been already ended, or if it is read-only

add

public void add(Iterable<? extends org.openrdf.model.Statement> statements)
         throws IOException,
                IllegalStateException

Description copied from interface: TripleTransaction

Adds all the RDF statements in the Iterable specified to the triple store. Implementations are designed to perform high throughput insertion. They are also allowed to buffer part or all of the operation, successfully returning before specified triples have been completely modified; in this case, it must be however guaranteed that subsequent calls to #query(SelectQuery, BindingSet) will 'see' all the triples added.

Specified by:

add in interface TripleTransaction

Parameters:

statements - the statements to add

Throws:

IOException - in case some IO error occurs, with no guarantee that the TripleStore is left in the same state if was when the method was called; note that this exception may trigger a rollback on the caller side

IllegalStateException - if the TripleTransaction has been already ended, or if it is read-only

remove

public void remove(Iterable<? extends org.openrdf.model.Statement> statements)
            throws IOException,
                   IllegalStateException

Description copied from interface: TripleTransaction

Removes all the RDF statements in the Iterable specified from the triple store. Implementations are designed to perform high throughput deletion. They are also allowed to return before specified triples have been completely removed; in this case, it must be however guaranteed that subsequent calls to #query(SelectQuery, BindingSet) will not 'see' any of the triples removed.

Specified by:

remove in interface TripleTransaction

Parameters:

statements - the statements to remove

Throws:

IOException - in case some IO error occurs, with no guarantee that the TripleStore is left in the same state if was when the method was called; note that this exception may trigger a rollback on the caller side

IllegalStateException - if the TripleTransaction has been already ended, or if it is read-only

end

public void end(boolean commit)
         throws IOException

Description copied from interface: TripleTransaction

Ends the transaction, either committing or rolling back its changes (if any). This method always tries to terminate the transaction: if commit is requested but fails, a rollback is forced by the method and an IOException is thrown. If it is not possible either to commit or rollback, then the TripleStore is possibly left in an unknown state and a DataCorruptedException is thrown to signal a data corruption situation that cannot be automatically recovered (apart from calling TripleStore.reset() and repopulating the TripleStore).

Specified by:

end in interface TripleTransaction

Parameters:

commit - true in case changes made by the transaction should be committed

Throws:

IOException - in case some IO error occurs or the commit request cannot be satisfied for any reason; it is however guaranteed that a forced rollback has been performed

DataCorruptedException - in case it was not possible either to commit or rollback, which implies the state of the TripleStore is unknown and automatic recovery is not possible (hence, data is corrupted)