org.lacibus.triplestore

Class TripleStore

java.lang.Object

org.lacibus.triplestore.TripleStore

All Implemented Interfaces:

java.io.Serializable, SourceConnectorClient

public class TripleStore
extends java.lang.Object
implements SourceConnectorClient, java.io.Serializable

A triple store holds items and triples from the sources to which it is connected. For triples with text and binary objects, an object is only retrieved from the source when its summary meets a search criterion.

The triple store has methods to connect and disconnect sources, to read items and triples in all connected sources and to search for triples in all connected sources. It has methods to create, delete, and update items and triples in connected sources that it owns.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
static long	hasCredentialRelationNr The numeric identifier of the special item representing the "has credential" verb
static long	hasSecretDigestRelationNr The numeric identifier of the special item representing the "has secret digest" verb
static long	highestLevelNr The numeric identifier of the special item representing the highest access level
static long	inferiorPermissionRelationNr The numeric identifier of the special item representing the inferior permission relation verb
static long	isAccessLevelRelationNr The numeric identifier of the special item representing the "is access level relation" verb
static long	lowestLevelNr The numeric identifier of the special item representing the lowest access level
static long	specialItemSource The special item source number.
static long	superiorPermissionRelationNr The numeric identifier of the special item representing the superior permission relation verb

Constructor Summary

Constructors

Constructor and Description
TripleStore(int stringCacheSize, int binaryCacheSize) Construct a new triple store

Method Summary

Modifier and Type	Method and Description
java.util.List<AccessLevel>	accessLevels(StoreSession session) Get the access levels visible to a store session
boolean	allTriplesVisible(Item subject, Item verb, StoreSession session) Determine whether all the triples with given subject and verb are visible to the requesting session.
void	applyDelta(long sourceNr, Delta delta, boolean load) Apply a delta
void	close() Close the store
void	connect(SourceConnector connector, StoreSession session) Connect to a source
void	create(SourceConnector connector, StoreSession session) Create a source
AccessLevel	createAccessLevel(long sourceNr, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a new access level with given access levels
Item	createCredential(AccessLevel level, StoreSession session) Create a credential for an access level.
AccessLevel	createLockedAccessLevel(long sourceNr, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a new access level with given access levels, and with its item locked.
Item	createLockedItem(long sourceNr, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a new item and return it locked
AccessLevel	createNamedAccessLevel(long sourceNr, java.lang.String name, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a named access level in a given source and with given only-read and read-or-write access levels.
Item	createNamedItem(long sourceNr, java.lang.String name, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a named item in a source, with access levels set to given values.
StoreSession	createStoreSession(Item credential, byte[] secret, StoreSession requestingSession) Create a store session with the access level that has a credential
Triple	createTriple(Item subject, Item verb, Datum object, StoreSession session) Create a new triple
Item	createUnlockedItem(SourceConnector connector, AccessLevel onlyReadLevel, AccessLevel readOrWriteLevel, StoreSession session) Create a new item and return it unlocked
boolean	deleteCredential(Item credential, StoreSession session) Delete a credential
boolean	deleteItem(Item it, StoreSession session) Delete an item
boolean	deleteTriple(Triple t, StoreSession session) Delete a triple.
void	disconnect(long sourceNr) Disconnect a source
boolean	ensureNoMatchingTriples(Item subject, Item verb, StoreSession session) Ensure that there are no triples with a given subject and verb
byte[]	generateSecret(Item credential, StoreSession session) Generate a secret for a credential, and store its digest as the unique secret digest for the credential
AccessLevel	getAccessLevel(Item item, StoreSession session) Get the access level represented by an item
Item	getAccessLevelRelationItem() Get the item that is the verb such that the subject of a triple with this verb represents an access level.
AccessLevelRelationsStatus	getAccessLevelRelationsStatus(StoreSession session) Get the superiority permissions and relations that are visible to a store session
AccessLevel	getAdminAccessLevel(long sourceNr) Get the administration access level of a source.
java.util.List<Triple>	getAllTriples(Item subject, Item verb, StoreSession session) Get all the triples with given subject and verb, or return null if some are not visible to the requesting session.
long	getHighestAccessLevelNr() Return the numeric identifier of the highest access level
long	getIsAccessLevelRelationNr()
Item	getItem(Id id, StoreSession session) Get an item.
java.lang.String	getItemName(Item item, StoreSession session) Get the name of an item if it is a named item.
Logger	getLogger() Get the logger
long	getLowestAccessLevelNr() Return the numeric identifier of the lowest access level
Item	getNamedItem(long sourceNr, java.lang.String name, StoreSession session) Get a named item in a source
AccessLevel	getOrCreateNamedAccessLevel(long sourceNr, java.lang.String name, StoreSession session) Get or create a named access level from a source, with write access level set to the access level of the requesting session, and read access level set to the lowest level.
Item	getOrCreateNamedItem(long sourceNr, java.lang.String name, StoreSession session) Get a named item in a source, creating it if it does not exist.
SourceConnector	getSourceConnector(long sourceNr) Get the connector for a given source
Item	getSpecialItemByName(java.lang.String name) Get a special item, given its name
long	getSpecialItemSourceNr()
Triple	getTriple(Id id, StoreSession session) Get a triple.
Datum	getTripleObject(Triple t, StoreSession session) Get the object of a triple
java.util.List<Triple>	getTriples(Item subject, Item verb, Datum object, StoreSession session) Get the triples with given subject, verb, and object
java.util.Set<AccessLevel>	getVisibleInferiors(AccessLevel level, StoreSession session) Get the set of access levels that are inferior to a given level and that are visible to the requesting store session
java.util.Set<AccessLevel>	getVisibleSuperiors(AccessLevel level, StoreSession session) Get the set of access levels that are superior to a given level and that are visible to the requesting store session
java.util.List<org.lacibus.settheoryrels.OrderedPair<AccessLevel>>	impliedAccessLevelRelationships(StoreSession session) List the implied access level relationships that are readable at the session access level
SessionIssuer	initialize() Return a session issuer when the store has been initialised.
boolean	isHighestAccessLevel(AccessLevel level) Determine whether an access level is the highest access level
boolean	isKnown(long sourceNr) Determine whether a source is known.
boolean	isOperational(long sourceNr) Determine whether a source is operational.
boolean	isSpecialItem(Item it) Determine whether an item is a special item.
boolean	isStatedAccessRelationship(AccessLevel superior, AccessLevel inferior) Determine whether one access level is stated to be superior to another
java.util.List<Item>	lockObjectsOfItem(Item item, Item[] verbs, StoreSession storeSession) Lock the item objects of triples whose subject is a given item and whose verbs are in a given set of verbs.
void	log(java.lang.Exception e) Report an exception
void	log(java.lang.String message) Report status or an error
AccessLevel	lowestAccessLevel() Get the lowest access level
boolean	nameItem(Item item, java.lang.String name, StoreSession session) Give an item a unique name.
void	orderByObjectSubjectVerb(java.util.List<Triple> triples) Sort a list of triples by object, then subject, then verb
void	orderBySubjectVerbObject(java.util.List<Triple> triples) Sort a list of triples by subject, then verb, then object
void	orderByVerbObjectSubject(java.util.List<Triple> triples) Sort a list of triples by verb, then object, then subject
Triple	replaceTripleObject(Triple t, Datum object, StoreSession session) Replace a triple's object
boolean	retireAccessLevel(AccessLevel level, AccessLevel replacement, StoreSession session) Retire an access level and replace it by by another.
boolean	setInferiorPermission(AccessLevel inferior, AccessLevel superior, StoreSession session) Permit one access level to be inferior to another.
void	setLogger(Logger logger) Set the logger
boolean	setSuperiorPermission(AccessLevel superior, AccessLevel inferior, StoreSession session) Permit one access level to be superior to another.
Triple	setUniqueObject(Item subject, Item verb, Datum object, StoreSession session) Ensure there is a unique triple with a given subject and verb, and that it has a given object.
Triple	setUniqueTriple(Item subject, Item verb, Datum object, StoreSession session) Ensure there is a unique triple with a given subject, verb and object.
int	sizeIndicator() Get an indication of the size of the triple store.
java.lang.String	specialItemName(Item it) Get the name of a special item
Triple	uniqueTriple(Item subject, Item verb, Datum object, StoreSession session) Get the unique triple with the given subject, verb, and object, if it is readable by the requesting store session.
void	unlockObjects(java.util.List<Item> objects, StoreSession storeSession) Unlock the objects in a list of objects.
boolean	unsetInferiorPermission(AccessLevel inferior, AccessLevel superior, StoreSession session) Remove a permission that an access level can be inferior to another.
boolean	unsetSuperiorPermission(AccessLevel superior, AccessLevel inferior, StoreSession session) Remove a permission that an access level can be superior to another.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

specialItemSource

public static final long specialItemSource

The special item source number. The special items do not exist in any source. Their ids have zero as source number.

See Also:

Constant Field Values

lowestLevelNr

public static final long lowestLevelNr

The numeric identifier of the special item representing the lowest access level

See Also:

Constant Field Values

highestLevelNr

public static final long highestLevelNr

The numeric identifier of the special item representing the highest access level

See Also:

Constant Field Values

isAccessLevelRelationNr

public static final long isAccessLevelRelationNr

The numeric identifier of the special item representing the "is access level relation" verb

See Also:

Constant Field Values

superiorPermissionRelationNr

public static final long superiorPermissionRelationNr

The numeric identifier of the special item representing the superior permission relation verb

See Also:

Constant Field Values

inferiorPermissionRelationNr

public static final long inferiorPermissionRelationNr

The numeric identifier of the special item representing the inferior permission relation verb

See Also:

Constant Field Values

hasCredentialRelationNr

public static final long hasCredentialRelationNr

The numeric identifier of the special item representing the "has credential" verb

See Also:

Constant Field Values

hasSecretDigestRelationNr

public static final long hasSecretDigestRelationNr

The numeric identifier of the special item representing the "has secret digest" verb

See Also:

Constant Field Values

Constructor Detail

TripleStore

public TripleStore(int stringCacheSize,
                   int binaryCacheSize)

Construct a new triple store

Parameters:

stringCacheSize - the number of strings in the string cache

binaryCacheSize - the number of byte arrays in the binary cache

Method Detail

sizeIndicator

public int sizeIndicator()

Get an indication of the size of the triple store. This indication does not relate to the numbers of items and triples that the store can hold, but may reflect the scale of use that is intended for it.

Returns:

the size of the string cache plus the size of the binary cache.

getLogger

public Logger getLogger()

Get the logger

Parameters:

logger - the logger to be set

setLogger

public void setLogger(Logger logger)

Set the logger

Parameters:

logger - the logger to be set

log

public void log(java.lang.String message)

Report status or an error

Parameters:

message - the status or error to be reported

log

public void log(java.lang.Exception e)

Report an exception

Parameters:

message - the status or error to be reported

initialize

public SessionIssuer initialize()
                         throws TripleStoreFatalException,
                                TripleStoreNonFatalException

Return a session issuer when the store has been initialised.

If the store is in its initial state, initialise it and return a session issuer.If it is already being initialized by another thread, wait until that process has completed, then return null.If the store has already been initialized, return null.

The session issuer is returned so that the software that set up the triple store is able to obtain store sessions and use it. This software is responsible for controlling the use of the issuer and the sessions that it issues to maintain secure access to the data in the store.

Returns:

a session issuer or null

Throws:

TripleStoreFatalException

TripleStoreNonFatalException

close

public void close()

Close the store

create

public void create(SourceConnector connector,
                   StoreSession session)
            throws java.lang.Exception

Create a source

Parameters:

connector - a source connector for the source

session - the requesting store session

Throws:

java.lang.Exception

connect

public void connect(SourceConnector connector,
                    StoreSession session)
             throws java.lang.Exception

Connect to a source

Parameters:

connector - a source connector for the source

session - the requesting store session

Throws:

java.lang.Exception

disconnect

public void disconnect(long sourceNr)
                throws TripleStoreNonFatalException,
                       TripleStoreFatalException,
                       SourceConnectorException,
                       NotInOperationException

Disconnect a source

Parameters:

sourceNr - the numeric identifier of the source to be disconnected

Throws:

TripleStoreFatalException

SourceConnectorException

NotInOperationException

TripleStoreNonFatalException

isKnown

public boolean isKnown(long sourceNr)

Determine whether a source is known. A source is known if the triple store has started to connect to it and it has not been disconnected.

Parameters:

sourceNr - the numeric identifier of a source

Returns:

true if the source with the given source number is known, false otherwise

getSourceConnector

public SourceConnector getSourceConnector(long sourceNr)

Get the connector for a given source

Parameters:

sourceNr - the numeric identifier of a source

Returns:

the connector for the given source

isOperational

public boolean isOperational(long sourceNr)

Determine whether a source is operational. A source is operational if the triple store has loaded all its items and triples and it has not been disconnected.

Parameters:

sourceNr - the numeric identifier of a source

Returns:

true if the source with the given source number is operational, false otherwise

getAdminAccessLevel

public AccessLevel getAdminAccessLevel(long sourceNr)
                                throws NotInOperationException

Get the administration access level of a source.

This method is typically invoked by an application after it has connected a source, to perform initialization and management operations.

Parameters:

sourceNr - a numeric source identifier

Returns:

the administration access level of the identified source

Throws:

NotInOperationException

applyDelta

public void applyDelta(long sourceNr,
                       Delta delta,
                       boolean load)
                throws TripleStoreNonFatalException,
                       SourceConnectorException,
                       TripleStoreFatalException,
                       NotInOperationException

Apply a delta

A delta is an instruction to add, remove or change an item or triple.

When a source is loaded while being connected, or when the triple store is synchronizing with a source, a set of deltas is loaded from it.

Specified by:

applyDelta in interface SourceConnectorClient

Parameters:

sourceNr - the numeric identifier of the source originating the delta

delta - a delta

load - true if the delta is loaded in a load operation, false if in a sync operation

Throws:

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

NotInOperationException

getAccessLevelRelationItem

public Item getAccessLevelRelationItem()

Get the item that is the verb such that the subject of a triple with this verb represents an access level. If the object of the triple is the same as the subject, then the access level has not been replaced, otherwise the access level represented by the subject has been replaced by the access level represented by the object.

Returns:

the access level relation item

getLowestAccessLevelNr

public long getLowestAccessLevelNr()

Description copied from interface: SourceConnectorClient

Return the numeric identifier of the lowest access level

Specified by:

getLowestAccessLevelNr in interface SourceConnectorClient

getHighestAccessLevelNr

public long getHighestAccessLevelNr()

Description copied from interface: SourceConnectorClient

Return the numeric identifier of the highest access level

Specified by:

getHighestAccessLevelNr in interface SourceConnectorClient

isHighestAccessLevel

public boolean isHighestAccessLevel(AccessLevel level)
                             throws TripleStoreNonFatalException

Determine whether an access level is the highest access level

Parameters:

level - an access level

Returns:

whether the given access level is the highest access level

Throws:

TripleStoreNonFatalException

lowestAccessLevel

public AccessLevel lowestAccessLevel()
                              throws NotInOperationException

Get the lowest access level

Returns:

the lowest access level

Throws:

NotInOperationException - if the triple store is not in operation

createAccessLevel

public AccessLevel createAccessLevel(long sourceNr,
                                     AccessLevel onlyReadLevel,
                                     AccessLevel readOrWriteLevel,
                                     StoreSession session)
                              throws NotInOperationException,
                                     SourceConnectorException,
                                     TripleStoreNonFatalException,
                                     TripleStoreFatalException

Create a new access level with given access levels

The new access level will be stated to be inferior to the session level, to ensure that the operation can be reversed within the same session.

The session must therefore have write access to its level item.

The session may not be at the lowest access level, since this cannot be superior to another level.

Parameters:

sourceNr - the numeric identifier of the source in which the access level is to be created.

onlyReadLevel - the only-read access level that the new access level is to have

readOrWriteLevel - the read-or-write access level that the new access level is to have

session - the requesting store session

Returns:

the new access level, with its item unlocked.

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

createLockedAccessLevel

public AccessLevel createLockedAccessLevel(long sourceNr,
                                           AccessLevel onlyReadLevel,
                                           AccessLevel readOrWriteLevel,
                                           StoreSession session)
                                    throws NotInOperationException,
                                           SourceConnectorException,
                                           TripleStoreNonFatalException,
                                           TripleStoreFatalException

Create a new access level with given access levels, and with its item locked.

The new access level will be stated to be inferior to the session level, to ensure that the operation can be reversed within the same session.

The session must therefore have write access to its level item.

The session may not be at the lowest access level, since this cannot be superior to another level.

Parameters:

sourceNr - the numeric identifier of the source in which the access level is to be created.

onlyReadLevel - the only-read access level that the new access level is to have

readOrWriteLevel - the read-or-write access level that the new access level is to have

session - the requesting store session

Returns:

the new access level, with its item locked.

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

getOrCreateNamedAccessLevel

public AccessLevel getOrCreateNamedAccessLevel(long sourceNr,
                                               java.lang.String name,
                                               StoreSession session)
                                        throws NotInOperationException,
                                               SourceConnectorException,
                                               TripleStoreNonFatalException,
                                               TripleStoreFatalException

Get or create a named access level from a source, with write access level set to the access level of the requesting session, and read access level set to the lowest level.

The access level's item is related to a given name by the source item of the source. Only one such item can exist an any particular source. (The access level's item is a named item like those created by the namedItem method.)

Parameters:

sourceNr - the numeric identifier of the source of the item

name - the name for the access level. This forms the key by which the named access level or its item can be retrieved.

session - the store session requesting the operation.

Returns:

the access level whose item is related to the given name by the source item of the source. If the access level did not exist but a named item with the given name did exist, or if it did exist but was not readable by the requesting session, or if the first item could not be locked, or the triple defining the named item could not be created, then null is returned.

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

createNamedAccessLevel

public AccessLevel createNamedAccessLevel(long sourceNr,
                                          java.lang.String name,
                                          AccessLevel onlyReadLevel,
                                          AccessLevel readOrWriteLevel,
                                          StoreSession session)
                                   throws NotInOperationException,
                                          SourceConnectorException,
                                          TripleStoreNonFatalException,
                                          TripleStoreFatalException

Create a named access level in a given source and with given only-read and read-or-write access levels.

The access level's item is related to a given name by the source item of the source. Only one such item can exist an any particular source. (The access level's item is a named item like those created by the namedItem method.)

Parameters:

sourceNr - the numeric identifier of the source in which the access level is to be created.

name - the name for the access level. This forms the key by which the named access level or its item can be retrieved.

onlyReadLevel - the only-read level of the access level to be created

readOrWriteLevel - the read-or-write level of the access level to be created

session - the store session requesting the operation.

Returns:

the access level whose item is related to the given name by the source item of the source if it was created, null otherwise. If an item (or access level) with the given name existed, or if the first item could not be locked, or the triple defining the named item could not be created, then the access level is not created and null is returned.

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

getAccessLevel

public AccessLevel getAccessLevel(Item item,
                                  StoreSession session)
                           throws NotInOperationException,
                                  TripleStoreNonFatalException

Get the access level represented by an item

Parameters:

item - the identifying item

session - the requesting store session, which must have read access to the item.

Returns:

the access level represented by the given item, or null if there is no access level represented by the item, or if the requesting session does not have read access to it.

Throws:

NotInOperationException

TripleStoreNonFatalException

accessLevels

public java.util.List<AccessLevel> accessLevels(StoreSession session)
                                         throws TripleStoreNonFatalException

Get the access levels visible to a store session

Parameters:

session - a store session

Returns:

a list of the access levels that can be read by the session. The list is not in any particular order.

Throws:

TripleStoreNonFatalException

setSuperiorPermission

public boolean setSuperiorPermission(AccessLevel superior,
                                     AccessLevel inferior,
                                     StoreSession session)
                              throws NotInOperationException,
                                     TripleStoreNonFatalException,
                                     TripleStoreFatalException,
                                     SourceConnectorException

Permit one access level to be superior to another. If the other is already permitted to be the inferior of the pair, make a stated superiority relationship between them.

The requesting store session must have locked the level that is permitted to be the superior one, and have read access to the other. Neither level may be being replaced.

Parameters:

superior - the level that is permitted to be the superior one

inferior - the level that the superior is permitted to be superior to

session - the requesting store session

Returns:

true if the permission was accepted, false otherwise. The permission will not be accepted if one of the relations is the predefined lowest or predefined highest level, or if the requesting store session does not have write access to the superior level, or does not have read access to the inferior level. If the superior level was already permitted to be superior to the other one, then true is returned and no change is made.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

setInferiorPermission

public boolean setInferiorPermission(AccessLevel inferior,
                                     AccessLevel superior,
                                     StoreSession session)
                              throws NotInOperationException,
                                     TripleStoreNonFatalException,
                                     TripleStoreFatalException,
                                     SourceConnectorException

Permit one access level to be inferior to another. If the other is already permitted to be the superior of the pair, make a stated superiority relationship between them.

The requesting store session must have locked the level that is permitted to be the inferior one, and have read access to the other. Neither level may be being replaced.

Parameters:

inferior - the level that is permitted to be the inferior one

superior - the level that the inferior is permitted to be inferior to

session - the requesting store session

Returns:

true if the permission was accepted, false otherwise. The permission will not be accepted if one of the relations is the predefined lowest or predefined highest level, or if the requesting store session does not have write access to the inferior level, or does not have read access to the superior level. If the inferior level was already permitted to be inferior to the other one, then true is returned and no change is made.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

unsetSuperiorPermission

public boolean unsetSuperiorPermission(AccessLevel superior,
                                       AccessLevel inferior,
                                       StoreSession session)
                                throws NotInOperationException,
                                       TripleStoreNonFatalException,
                                       TripleStoreFatalException,
                                       SourceConnectorException

Remove a permission that an access level can be superior to another. Any stated relationship that the level is superior to the other is removed also.

The requesting store session must have locked the superior level and have read access to the other level, and must continue to have write access to the superior level and read access to the other level once the permission has been removed. Neither level may be being replaced.

Parameters:

superior - the level that is permitted to be superior to the other one

inferior - the level that the superior level is permitted to be superior to

session - the requesting store session

Returns:

true if the removal was accepted, false otherwise. The removal will not be accepted if the superior relation is not permitted to be superior to the other one, or if one of the relations is the predefined lowest or predefined highest level, or if the requesting store session does not have write access to to the superior level, or does not have read access to the other level, or if the requesting store session would not continue to have write access to the superior and read access to the other level after the operation.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

unsetInferiorPermission

public boolean unsetInferiorPermission(AccessLevel inferior,
                                       AccessLevel superior,
                                       StoreSession session)
                                throws NotInOperationException,
                                       TripleStoreNonFatalException,
                                       TripleStoreFatalException,
                                       SourceConnectorException

Remove a permission that an access level can be inferior to another. Any stated relationship that the other level is superior to the level is removed also.

The requesting store session must have locked the inferior level and have read access to the other level, and must continue to have write access to the inferior level and read access to the other level once the permission has been removed. Neither level may be being replaced.

Parameters:

inferior - the level that is permitted to be inferior to the other one

superior - the level that the inferior level is permitted to be inferior to

session - the requesting store session

Returns:

true if the removal was accepted, false otherwise. The removal will not be accepted if the inferior relation is not permitted to be inferior to the other one, or if one of the relations is the predefined lowest or predefined highest level, or if the requesting store session does not have write access to to the inferior level, or does not have read access to the other level, or if the requesting store session would not continue to have write access to the inferior and read access to the other level after the operation.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

isStatedAccessRelationship

public boolean isStatedAccessRelationship(AccessLevel superior,
                                          AccessLevel inferior)
                                   throws NotInOperationException,
                                          TripleStoreNonFatalException

Determine whether one access level is stated to be superior to another

Parameters:

superior - the possibly superior level

inferior - the possibly inferior level

Returns:

true if the possibly superior level is really stated to be superior to the possibly inferior one, false otherwise

Throws:

NotInOperationException

TripleStoreNonFatalException

impliedAccessLevelRelationships

public java.util.List<org.lacibus.settheoryrels.OrderedPair<AccessLevel>> impliedAccessLevelRelationships(StoreSession session)
                                                                                                   throws NotInOperationException,
                                                                                                          TripleStoreNonFatalException

List the implied access level relationships that are readable at the session access level

Parameters:

session - the store session requesting the operation

Returns:

an unsorted list of the implied access level relationships for which both elements are readable by the session.

Throws:

NotInOperationException

TripleStoreNonFatalException

getAccessLevelRelationsStatus

public AccessLevelRelationsStatus getAccessLevelRelationsStatus(StoreSession session)
                                                         throws TripleStoreNonFatalException,
                                                                TripleStoreFatalException,
                                                                SourceConnectorException,
                                                                NotInOperationException

Get the superiority permissions and relations that are visible to a store session

Parameters:

session - a store session

Returns:

the superiority permissions and relations that are visible to the given store session

Throws:

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

NotInOperationException

getVisibleSuperiors

public java.util.Set<AccessLevel> getVisibleSuperiors(AccessLevel level,
                                                      StoreSession session)
                                               throws TripleStoreNonFatalException,
                                                      NotInOperationException

Get the set of access levels that are superior to a given level and that are visible to the requesting store session

Parameters:

level - an access level

session - the requesting store session

Returns:

the set of access levels that are superior to the given access level and visible to the store session

Throws:

TripleStoreNonFatalException

NotInOperationException

getVisibleInferiors

public java.util.Set<AccessLevel> getVisibleInferiors(AccessLevel level,
                                                      StoreSession session)
                                               throws TripleStoreNonFatalException,
                                                      NotInOperationException

Get the set of access levels that are inferior to a given level and that are visible to the requesting store session

Parameters:

level - an access level

session - the requesting store session

Returns:

the set of access levels that are superior to the given access level and visible to the store session

Throws:

TripleStoreNonFatalException

NotInOperationException

retireAccessLevel

public boolean retireAccessLevel(AccessLevel level,
                                 AccessLevel replacement,
                                 StoreSession session)
                          throws NotInOperationException,
                                 TripleStoreNonFatalException,
                                 TripleStoreFatalException,
                                 SourceConnectorException

Retire an access level and replace it by by another.

The requesting session must have locked the retired access level. The retired level must not be the highest or lowest access level, and must not be the same as the access level of the requesting session. The replacement may not be the highest access level. It may be the lowest access level. If it is not, the requesting session must have locked it. It must not be the same as the access level that it is replacing, and must not itself have been replaced.

Retirement of an access level implies the removal of its stated relationships, the deletion of its representing item, and the consequent deletion of all triples of which that item is subject, verb, or object. Note that the same session may not be able to create another level with the same relationships as the retired level.

Testing whether one access level is superior to another is a frequently-used operation. It is performed without using code that is synchronized on the access levels in question, to avoid deadlocks, and to improve performance. The retirement mechanism must work under these circumstances.

When an access level is retired, its "replacement" field is set to reference its replacement. This is an atomic operation. The replacement is used in place of the level when the only-read or the read-or-write level of an item has been retired, and access to the item is checked.

If the access level of a session is replaced, the replacement field is not used when checking whether the session can read or write an item. Instead, a TripleStoreNonFatalException is thrown.

Once the "replacement" field has been changed, the access level remains usable for a considerable time. A thread that has tested the access level and determined that it has not been retired should encounter no problems if the level is retired while the thread is using it.

Changes to item read and write levels, and access level replacements, are all done by threads that have obtained the access levels lock. An item can therefore not have its read or write access level set to a level that has been retired.

A background task goes through the items and replaces retired only-read and read-or-write levels with their replacements. By this means, all references in the triple store to the retired level are eventually removed.

Parameters:

level - the access level to be replaced. This level will be deleted once it has been replaced.

replacement - the replacement access level

session - the requesting session

Returns:

true if the operation was performed, false otherwise

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

createCredential

public Item createCredential(AccessLevel level,
                             StoreSession session)
                      throws NotInOperationException,
                             TripleStoreNonFatalException,
                             SourceConnectorException,
                             TripleStoreFatalException

Create a credential for an access level. The credential will be represented by a new item in the same source as the access level.

Parameters:

level - an access level

session - the requesting store session, whose access level must be superior to the admin access level of the source of the access level that will have the credential

Returns:

the item representing the created credential, or null if a credential cannot be created.

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

generateSecret

public byte[] generateSecret(Item credential,
                             StoreSession session)
                      throws java.security.NoSuchAlgorithmException,
                             NotInOperationException,
                             TripleStoreNonFatalException,
                             SourceConnectorException,
                             TripleStoreFatalException

Generate a secret for a credential, and store its digest as the unique secret digest for the credential

Parameters:

credential - a credential

session - the requesting store session, whose access level must be superior to the admin access level of the source of the credential

Returns:

the created secret, or null if its digest cannot be stored. The previous secret may no longer be valid if null is returned.

Throws:

java.security.NoSuchAlgorithmException

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

createStoreSession

public StoreSession createStoreSession(Item credential,
                                       byte[] secret,
                                       StoreSession requestingSession)
                                throws TripleStoreNonFatalException,
                                       TripleStoreFatalException,
                                       SourceConnectorException,
                                       NotInOperationException,
                                       java.security.NoSuchAlgorithmException

Create a store session with the access level that has a credential

Parameters:

credential - a credential

secret - the credential's secret

requestingSession -

Returns:

a store session with the access level that has the credential, or null if the secret does not match the secret stored for the credential or the access level cannot be found

Throws:

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

NotInOperationException

java.security.NoSuchAlgorithmException

deleteCredential

public boolean deleteCredential(Item credential,
                                StoreSession session)
                         throws NotInOperationException,
                                TripleStoreNonFatalException,
                                SourceConnectorException,
                                TripleStoreFatalException

Delete a credential

Parameters:

credential - the credential to be deleted

session - the requesting store session, whose access level must be superior to the admin access level of the source of the credential

Returns:

true if the credential is deleted, false otherwise

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

getSpecialItemSourceNr

public long getSpecialItemSourceNr()

Specified by:

getSpecialItemSourceNr in interface SourceConnectorClient

Returns:

the numeric identifier of the special item source

getIsAccessLevelRelationNr

public long getIsAccessLevelRelationNr()

Specified by:

getIsAccessLevelRelationNr in interface SourceConnectorClient

Returns:

the numeric identifier of the item that is the verb in access level definition triples

createUnlockedItem

public Item createUnlockedItem(SourceConnector connector,
                               AccessLevel onlyReadLevel,
                               AccessLevel readOrWriteLevel,
                               StoreSession session)
                        throws NotInOperationException,
                               SourceConnectorException,
                               TripleStoreNonFatalException,
                               TripleStoreFatalException

Create a new item and return it unlocked

Parameters:

connector - the connector to the source in which the item is to be written

onlyReadLevel - the only-read level that the item is to have

readOrWriteLevel - the read-or-write level that the item is to have

session - the store session requesting creation of the new item.

Returns:

the item that is created, unlocked, or null if it cannot be created

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

createLockedItem

public Item createLockedItem(long sourceNr,
                             AccessLevel onlyReadLevel,
                             AccessLevel readOrWriteLevel,
                             StoreSession session)
                      throws NotInOperationException,
                             SourceConnectorException,
                             TripleStoreNonFatalException,
                             TripleStoreFatalException

Create a new item and return it locked

Parameters:

sourceNr - the numeric identifier of the source in which the item is to be written

onlyReadLevel - the only-read level that the item is to have

readOrWriteLevel - the read-or-write level that the item is to have

session - the store session requesting creation of the new item.

Returns:

the item that is created, locked, or null if it cannot be created

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

getOrCreateNamedItem

public Item getOrCreateNamedItem(long sourceNr,
                                 java.lang.String name,
                                 StoreSession session)
                          throws NotInOperationException,
                                 SourceConnectorException,
                                 TripleStoreFatalException,
                                 TripleStoreNonFatalException

Get a named item in a source, creating it if it does not exist. If a new named item is created, it has read-or-write access level set to the access level of the requesting session, and only-read access level set to the lowest level.

The item is related to a given name by the source item of the source. Only one such item can exist in any particular source.

Parameters:

sourceNr - the numeric identifier of the source of the item.

name - the name for the item. This forms the key by which the named item can be retrieved.

session - the store session requesting the operation.

Returns:

the item that is related to the given name by the source item of the given source. If the item exists but is not visible to the requesting session, or if the source item cannot be locked, or the triple defining the named item could not be created, then null is returned.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

createNamedItem

public Item createNamedItem(long sourceNr,
                            java.lang.String name,
                            AccessLevel onlyReadLevel,
                            AccessLevel readOrWriteLevel,
                            StoreSession session)
                     throws NotInOperationException,
                            SourceConnectorException,
                            TripleStoreFatalException,
                            TripleStoreNonFatalException

Create a named item in a source, with access levels set to given values.

The item is related to a given name by the source item of the source. Only one such item can exist in any particular source.

Parameters:

sourceNr - the numeric identifier of the source of the item.

name - the name for the item. This forms the key by which the named item can be retrieved.

onlyReadLevel - the only-read access level that the newly-created item is to have

readOrWriteLevel - the read-or-write access level that the newly- created item is to have.

session - the store session requesting the operation.

Returns:

a newly-created item that is related to a given name by the source item of the triple store, if such an item does not already exist. If such an item does exist, or if the source item cannot be locked, or the triple defining the named item could not be created, then null is returned.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

nameItem

public boolean nameItem(Item item,
                        java.lang.String name,
                        StoreSession session)
                 throws TripleStoreNonFatalException,
                        SourceConnectorException,
                        NotInOperationException,
                        TripleStoreFatalException

Give an item a unique name. If the item already has a name, then rename it.

The item is related to a given name by the source item of its source. Only one such item can exist in any particular source.

If the item already has the given name, no change is made.

Parameters:

item - the item to be named. It must be locked by the requesting store session before this method is invoked.

name - the name that the item is to have

session - the requesting store session

Returns:

whether the item has the given name as a result of this method invocation. If the item is not locked then no change is made and false is returned.

Throws:

TripleStoreNonFatalException

SourceConnectorException

NotInOperationException

TripleStoreFatalException

getNamedItem

public Item getNamedItem(long sourceNr,
                         java.lang.String name,
                         StoreSession session)
                  throws TripleStoreNonFatalException,
                         SourceConnectorException,
                         TripleStoreFatalException,
                         NotInOperationException

Get a named item in a source

Parameters:

sourceNr - the numeric identifier of a source

name - the name of a named item in the source

session - the requesting store session

Returns:

the item in the given source with the given name, or null if it cannot be found.

Throws:

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

NotInOperationException

getItem

public Item getItem(Id id,
                    StoreSession session)
             throws NotInOperationException,
                    TripleStoreNonFatalException

Get an item.

The requesting store session must have read access to the item. The item must be from a connected source

Parameters:

id - the item's identifier

session - the requesting store session

Returns:

the item with the given identifier, or null if there is no such item

Throws:

NotInOperationException

TripleStoreNonFatalException

getItemName

public java.lang.String getItemName(Item item,
                                    StoreSession session)
                             throws NotInOperationException,
                                    SourceConnectorException,
                                    TripleStoreNonFatalException,
                                    TripleStoreFatalException

Get the name of an item if it is a named item. A named item is related to its name by its source's first item.

Parameters:

item - an item

session - the requesting session

Returns:

the name of the item if it has one and is visible to the requesting session, null otherwise.

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

deleteItem

public boolean deleteItem(Item it,
                          StoreSession session)
                   throws NotInOperationException,
                          TripleStoreNonFatalException,
                          SourceConnectorException

Delete an item

The item is marked as deleted and is deleted from the store.

The item must not be a special item or the item of an access level or a source item.

Parameters:

it - the item to be deleted

session - the store session requesting deletion of the item. The item must have been locked by this session for the operation to succeed.

Returns:

true if the item was deleted, false otherwise (including if there is no such item or the item was already deleted or the item was a special item or the item of an access level)

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

isSpecialItem

public boolean isSpecialItem(Item it)
                      throws TripleStoreNonFatalException,
                             NotInOperationException

Determine whether an item is a special item.

Parameters:

it - an item

Returns:

true if and only if the given item is a special one.

Throws:

NotInOperationException

TripleStoreNonFatalException

specialItemName

public java.lang.String specialItemName(Item it)
                                 throws NotInOperationException

Get the name of a special item

Parameters:

it - a special item

Returns:

the name of the special item, or null if the item is not a special item.

Throws:

NotInOperationException

getSpecialItemByName

public Item getSpecialItemByName(java.lang.String name)
                          throws NotInOperationException

Get a special item, given its name

Parameters:

name - a name

Returns:

the special item with the given name, or null if it is not the name of a special item.

Throws:

NotInOperationException

lockObjectsOfItem

public java.util.List<Item> lockObjectsOfItem(Item item,
                                              Item[] verbs,
                                              StoreSession storeSession)
                                       throws TripleStoreNonFatalException

Lock the item objects of triples whose subject is a given item and whose verbs are in a given set of verbs.

This method is used by applications that need to process an item and other items related to it together - for example that need to delete an item together with the items related to it.

Parameters:

item - the given item. It must have been locked by the requesting session when the method is invoked.

verbs - the verbs of triples whose subject is the given item and whose item objects are to be locked.

storeSession - the requesting store session.

Returns:

a list of the object items of triples whose subject is the given item and whose verbs are in the given set of verbs, or null. If a list is returned then all the items in it are locked, and the list is ordered by the time of locking, with the most recently locked item first. If any of the object items cannot be locked - including object items that are not visible to the requesting session - then null is returned.

Throws:

TripleStoreNonFatalException

unlockObjects

public void unlockObjects(java.util.List<Item> objects,
                          StoreSession storeSession)

Unlock the objects in a list of objects.

Parameters:

objects - a list of objects

storeSession - the requesting store session

getTriple

public Triple getTriple(Id id,
                        StoreSession session)
                 throws NotInOperationException,
                        TripleStoreNonFatalException

Get a triple.

The requesting session must have read access to the triple's subject and verb, and to the object if this is an item. The triple must be from a connected source.

Parameters:

id - the identifier of the requested triple

session - the requesting store session

Returns:

the triple with the given identifier, or null if there is no such triple, or the session does not have read access, or the triple's subject verb or object has been deleted.

Throws:

NotInOperationException

TripleStoreNonFatalException

createTriple

public Triple createTriple(Item subject,
                           Item verb,
                           Datum object,
                           StoreSession session)
                    throws NotInOperationException,
                           SourceConnectorException,
                           TripleStoreNonFatalException,
                           TripleStoreFatalException

Create a new triple

Parameters:

subject - the item that is the triple's subject. This item must have been locked by the requesting store session for the operation to succeed, and the requesting store session must have write access to it.

verb - the item that is the triple's verb. The requesting store session must have read access to the verb. The verb must not be a special item (triples with special items as verbs are created by special-purpose methods).

object - the Datum to be set as the triple's object. The requesting store session must have read access to its value if that value is an item.

session - the store session requesting creation of the new triple.

Returns:

the triple that is created, or null if it cannot be created as specified

Throws:

NotInOperationException

SourceConnectorException

TripleStoreNonFatalException

TripleStoreFatalException

replaceTripleObject

public Triple replaceTripleObject(Triple t,
                                  Datum object,
                                  StoreSession session)
                           throws NotInOperationException,
                                  TripleStoreNonFatalException,
                                  TripleStoreFatalException,
                                  SourceConnectorException

Replace a triple's object

Note that the triple will not change, but a new triple with updated information - including the object and summary value - will be returned and should be used in place of the original triple. The new triple will have a different numeric identifier to the original triple.

Parameters:

t - the triple whose object is to be replaced. Its subject must have been locked by the requesting store session. The requesting store session must have read access to its verb. The verb must not be a special item or a source item (triples with special items or source items as verbs are updated by special-purpose methods).

object - the datum that is to be the triple's new object. The requesting store session must have read access to its value if that value is an item.

session - the store session requesting the triple be updated.

Returns:

an updated copy of the triple if it was put successfully, null otherwise

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

getTripleObject

public Datum getTripleObject(Triple t,
                             StoreSession session)
                      throws NotInOperationException,
                             SourceConnectorException,
                             TripleStoreNonFatalException,
                             TripleStoreFatalException

Get the object of a triple

Parameters:

session - the store session requesting the operation. It must have read access to the subject and verb, and to the object if this is an item.

t - the triple whose object is to be returned

Returns:

the triple's object

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

deleteTriple

public boolean deleteTriple(Triple t,
                            StoreSession session)
                     throws NotInOperationException,
                            TripleStoreNonFatalException,
                            SourceConnectorException,
                            TripleStoreFatalException

Delete a triple.

Parameters:

t - the triple to be deleted. Its subject must have been locked by the requesting store session and the requesting store session must have write access to it. The requesting store session must have read access to its verb, and to its object if this is an item. The verb must not be a special item or a source item (triples with special items or source items as verbs are deleted by special-purpose methods).

session - the store session requesting the triple be deleted.

Returns:

true if the triple was deleted, false otherwise

Throws:

NotInOperationException

TripleStoreNonFatalException

SourceConnectorException

TripleStoreFatalException

getTriples

public java.util.List<Triple> getTriples(Item subject,
                                         Item verb,
                                         Datum object,
                                         StoreSession session)
                                  throws TripleStoreNonFatalException,
                                         TripleStoreFatalException,
                                         SourceConnectorException,
                                         NotInOperationException

Get the triples with given subject, verb, and object

Parameters:

subject - the given subject, or null, in which case all subjects match

verb - the given verb, or null, in which case all verbs match

object - the given object, or null, in which case all objects match

session - the store session requesting the triples.

Returns:

a list of the triples that match and such that the requesting session has read access to the subject and verb, and also to the object if this is an item

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

getAllTriples

public java.util.List<Triple> getAllTriples(Item subject,
                                            Item verb,
                                            StoreSession session)
                                     throws TripleStoreNonFatalException,
                                            TripleStoreFatalException,
                                            SourceConnectorException,
                                            NotInOperationException

Get all the triples with given subject and verb, or return null if some are not visible to the requesting session.

Parameters:

subject - the given subject

verb - the given verb

session - the store session requesting the triples.

Returns:

a list of the triples that match and such that the requesting session has read access to the subject and verb, and also to the object if this is an item, or null if there is a matching triple that the requesting session cannot read, or if the supplied subject or verb is null

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

allTriplesVisible

public boolean allTriplesVisible(Item subject,
                                 Item verb,
                                 StoreSession session)
                          throws TripleStoreNonFatalException,
                                 TripleStoreFatalException,
                                 SourceConnectorException,
                                 NotInOperationException

Determine whether all the triples with given subject and verb are visible to the requesting session. The subject must be locked by the requesting session when this methoid is invoked.

Parameters:

subject - the given subject

verb - the given verb

session - the requesting store session.

Returns:

true if the subject is locked by the requesting session and all the triples with given subject and verb are visible to the requesting session, false otherwise.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

orderBySubjectVerbObject

public void orderBySubjectVerbObject(java.util.List<Triple> triples)
                              throws NotInOperationException

Sort a list of triples by subject, then verb, then object

Parameters:

triples - the list to be sorted

Throws:

NotInOperationException - if the triple store is not in operation

orderByVerbObjectSubject

public void orderByVerbObjectSubject(java.util.List<Triple> triples)
                              throws NotInOperationException

Sort a list of triples by verb, then object, then subject

Parameters:

triples - the list to be sorted

Throws:

NotInOperationException - if the triple store is not in operation

orderByObjectSubjectVerb

public void orderByObjectSubjectVerb(java.util.List<Triple> triples)
                              throws NotInOperationException

Sort a list of triples by object, then subject, then verb

Parameters:

triples - the list to be sorted

Throws:

NotInOperationException - if the triple store is not in operation

uniqueTriple

public Triple uniqueTriple(Item subject,
                           Item verb,
                           Datum object,
                           StoreSession session)
                    throws NotInOperationException,
                           TripleStoreNonFatalException,
                           TripleStoreFatalException,
                           SourceConnectorException

Get the unique triple with the given subject, verb, and object, if it is readable by the requesting store session.

Parameters:

subject - the given subject, or null, in which case all subjects match

verb - the given verb, or null, in which case all verbs match

object - the given object, or null, in which case all objects match

session - the store session requesting the triples.

Returns:

the triple if there is exactly one that matches and it is readable by the session, or null.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

setUniqueTriple

public Triple setUniqueTriple(Item subject,
                              Item verb,
                              Datum object,
                              StoreSession session)
                       throws NotInOperationException,
                              TripleStoreNonFatalException,
                              TripleStoreFatalException,
                              SourceConnectorException

Ensure there is a unique triple with a given subject, verb and object. Delete other triples with this subject verb and object if they exist and can be deleted by the requesting store session. If one exists that cannot be deleted, return null.

Parameters:

subject - the given subject. It must be locked by the requesting store session before this method is invoked

verb - the given verb. The requesting store session must have read access to it

object - the given object. The requesting store session must have read access to it if it is an item.

session - the requesting store session

Returns:

the unique triple with the given subject, verb and object if it already exists or can be created, null otherwise.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

setUniqueObject

public Triple setUniqueObject(Item subject,
                              Item verb,
                              Datum object,
                              StoreSession session)
                       throws NotInOperationException,
                              TripleStoreNonFatalException,
                              TripleStoreFatalException,
                              SourceConnectorException

Ensure there is a unique triple with a given subject and verb, and that it has a given object. Delete other triples with this subject and verb if they exist and can be deleted by the requesting store session. If one exists that cannot be deleted, return null.

Parameters:

subject - the given subject. It must be locked by the requesting store session before this method is invoked

verb - the given verb. The requesting store session must have read access to it

object - the given object. The requesting store session must have read access to it if it is an item.

session - the requesting store session

Returns:

the unique triple with the given subject and verb if it already exists with the given object or can be created with the given object.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException

ensureNoMatchingTriples

public boolean ensureNoMatchingTriples(Item subject,
                                       Item verb,
                                       StoreSession session)
                                throws NotInOperationException,
                                       TripleStoreNonFatalException,
                                       TripleStoreFatalException,
                                       SourceConnectorException

Ensure that there are no triples with a given subject and verb

Parameters:

subject - the subject

verb - the verb

session - the requesting store session

Returns:

true if there were no matching triples or all matching triples have been deleted, false if there were matching triples that could not be deleted. If false is returned then no triples will have been deleted.

Throws:

NotInOperationException

TripleStoreNonFatalException

TripleStoreFatalException

SourceConnectorException