eu.fbk.knowledgestore.datastore

Class ForwardingDataTransaction

java.lang.Object

com.google.common.collect.ForwardingObject

eu.fbk.knowledgestore.datastore.ForwardingDataTransaction

All Implemented Interfaces:

DataTransaction

public abstract class ForwardingDataTransaction
extends ForwardingObject
implements DataTransaction

A DataTransaction forwarding all its method calls to another DataTransaction.

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

Constructor Summary

Constructors

Constructor and Description
ForwardingDataTransaction()

Method Summary

Modifier and Type	Method and Description
long	count(org.openrdf.model.URI type, XPath condition) Counts the records having the type and matching the optional condition specified.
protected abstract DataTransaction	delegate()
void	delete(org.openrdf.model.URI type, org.openrdf.model.URI id) Deletes the record stored in the DataStore with the ID specified.A record may or may not be stored for the specified ID; in case it exists, it is deleted by the operation.
void	end(boolean commit) Ends the transaction, either committing or rolling back its changes (if any).
Stream<Record>	lookup(org.openrdf.model.URI type, Set<? extends org.openrdf.model.URI> ids, Set<? extends org.openrdf.model.URI> properties) Returns a stream of records having the type and IDs specified.
Stream<Record>	match(Map<org.openrdf.model.URI,XPath> conditions, Map<org.openrdf.model.URI,Set<org.openrdf.model.URI>> ids, Map<org.openrdf.model.URI,Set<org.openrdf.model.URI>> properties) Evaluates a match request with the parameters supplied.
Stream<Record>	retrieve(org.openrdf.model.URI type, XPath condition, Set<? extends org.openrdf.model.URI> properties) Returns a stream of records having the type and matching the optional condition specified.
void	store(org.openrdf.model.URI type, Record record) Stores a record in the DataStore.

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

ForwardingDataTransaction

public ForwardingDataTransaction()

Method Detail

delegate

protected abstract DataTransaction delegate()

Specified by:

delegate in class ForwardingObject

lookup

public Stream<Record> lookup(org.openrdf.model.URI type,
                             Set<? extends org.openrdf.model.URI> ids,
                             @Nullable
                             Set<? extends org.openrdf.model.URI> properties)
                      throws IOException,
                             IllegalArgumentException,
                             IllegalStateException

Description copied from interface: DataTransaction

Returns a stream of records having the type and IDs specified.

Specified by:

lookup in interface DataTransaction

Parameters:

type - the URI of the type of records to return

ids - a set with the IDs of the records to return, not to be modified by the method

properties - a set with the properties to return for matching records, not modified by the method; if null, all the available properties must be returned

Returns:

a stream with the records matching the IDs and type specified, possibly empty and in no particular order

Throws:

IOException - in case some IO error occurs

IllegalArgumentException - in case the type specified is not supported

IllegalStateException - if the DataTransaction has been already ended

retrieve

public Stream<Record> retrieve(org.openrdf.model.URI type,
                               @Nullable
                               XPath condition,
                               @Nullable
                               Set<? extends org.openrdf.model.URI> properties)
                        throws IOException,
                               IllegalArgumentException,
                               IllegalStateException

Description copied from interface: DataTransaction

Returns a stream of records having the type and matching the optional condition specified.

Specified by:

retrieve in interface DataTransaction

Parameters:

type - the URI of the type of records to return

condition - an optional condition to be satisfied by matching records; if null, no condition must be checked

properties - a set with the properties to return for matching records, not modified by the method; if null, all the available properties must be returned

Returns:

a stream over the records matching the condition and type specified, possibly empty and in no particular order

Throws:

IOException - in case some IO error occurs

IllegalArgumentException - in case the type specified is not supported

IllegalStateException - if the DataTransaction has been already ended

count

public long count(org.openrdf.model.URI type,
                  @Nullable
                  XPath condition)
           throws IOException,
                  IllegalArgumentException,
                  IllegalStateException

Description copied from interface: DataTransaction

Counts the records having the type and matching the optional condition specified. This method performs similarly to DataTransaction.retrieve(URI, XPath, Set), but returns only the number of matching instances instead of retrieving the corresponding Record objects.

Specified by:

count in interface DataTransaction

Parameters:

type - the URI of the type of records to return

condition - an optional condition to be satisfied by matching records; if null, no condition must be checked

Returns:

the number of records matching the optional condition and type specified

Throws:

IOException - in case some IO error occurs

IllegalArgumentException - in case the type specified is not supported

IllegalStateException - if the DataTransaction has been already ended

match

public Stream<Record> match(Map<org.openrdf.model.URI,XPath> conditions,
                            Map<org.openrdf.model.URI,Set<org.openrdf.model.URI>> ids,
                            Map<org.openrdf.model.URI,Set<org.openrdf.model.URI>> properties)
                     throws IOException,
                            IllegalStateException

Description copied from interface: DataTransaction

Evaluates a match request with the parameters supplied. The operation:

1. Considers all the combinations <resource, mention, entity, axiom> such that
   • mention KS.MENTION_OF resource;
   • mention KS.REFERS_TO entity (optional if no condition or projection on entities);
   • mention KS.EXPRESSES axiom (optional if no condition or projection on axioms).
2. Filters the combinations so that optional conditions / ids selections on resource, mention, entity and axiom components are satisfied.
3. Perform projection with duplicate removal of filtered combinations, keeping only the components occurring in properties.keySet(), returning for each component the subset of properties of properties.get(component_type_URI).

In the maps supplied as parameters, components are identified by their type URI, that is KS.RESOURCE, KS.MENTION, KS.ENTITY and KS.AXIOM.

Specified by:

match in interface DataTransaction

Parameters:

conditions - a non-null map with optional component conditions, indexed by the component type URI; note the map may be possibly empty or contain conditions only for a subset of components

ids - a non-null map with optional ID selections for different components, indexed by the component type URI; note the map may be possibly empty or contain selections only for a subset of components

properties - a non-null, non-empty map with the properties to return for different components, indexed by the component type URI; if the set of property URIs mapped to a component is null or empty, then all the properties of the component should be returned; if a component is not referenced in the map, then it must not be returned

Returns:

a Stream of combination records

Throws:

IOException - in case some IO error occurs

IllegalStateException - if the DataTransaction has been already ended

store

public void store(org.openrdf.model.URI type,
                  Record record)
           throws IOException,
                  IllegalStateException

Description copied from interface: DataTransaction

Stores a record in the DataStore. A record may or may not exist for the same ID; in case it exists, it is replaced by the newly specified record. In case the method call returns successfully, there is no guarantee that the write operation completed (e.g., because of internal buffering); however, it is guaranteed (e.g., via internal flushing) that read operations called subsequently will see the result of the modification. In case the method call fails with an IOException, there is no guarantee that the DataStore is left in the same state it was at the time of calling.

Specified by:

store in interface DataTransaction

Parameters:

type - the URI of the type of record to store, not null

record - the record to store, not null

Throws:

IOException - in case the operation failed, with no guarantee that the DataStore 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 DataTransaction has been already ended, or if it is read-only

delete

public void delete(org.openrdf.model.URI type,
                   org.openrdf.model.URI id)
            throws IOException,
                   IllegalStateException

Description copied from interface: DataTransaction

Deletes the record stored in the DataStore with the ID specified.A record may or may not be stored for the specified ID; in case it exists, it is deleted by the operation. In case the method call returns successfully, there is no guarantee that the write operation completed (e.g., because of internal buffering); however, it is guaranteed (e.g., via internal flushing) that read operations called subsequently will see the result of the modification. In case the method call fails with an IOException, there is no guarantee that the DataStore is left in the same state it was at the time of calling.

Specified by:

delete in interface DataTransaction

Parameters:

type - the URI of the type of record to store, not null

id - the ID of the record to delete, not null

Throws:

IOException - in case the operation failed, with no guarantee that the DataStore 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 DataTransaction has been already ended, or if it is read-only

end

public void end(boolean commit)
         throws IOException,
                IllegalStateException

Description copied from interface: DataTransaction

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 DataStore is possibly left in an unknown state and a DataCorruptedException is thrown to signal a data corruption situation that cannot be automatically recovered.

Specified by:

end in interface DataTransaction

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 DataStore is unknown and automatic recovery is not possible (hence, data is corrupted)

IllegalStateException - if the DataTransaction has been already ended