org.linqs.psl.database

Class Database

java.lang.Object

org.linqs.psl.database.Database

All Implemented Interfaces:

ReadableDatabase, WritableDatabase

Direct Known Subclasses:

RDBMSDatabase

public abstract class Database
extends Object
implements ReadableDatabase, WritableDatabase

A data model for retrieving and persisting GroundAtoms. Every GroundAtom retrieved from a Database is either a RandomVariableAtom or an ObservedAtom. The method ReadableDatabase.getAtom(Predicate, Constant...) determines which type a GroundAtom is. In addition, a GroundAtom with a StandardPredicate can be persisted in a Database. If a GroundAtom is persisted, it is persisted in one of the Partitions the Database can read and is available for querying via ReadableDatabase.executeQuery(DatabaseQuery).

Setup

Databases are instantiated via DataStore.getDatabase(org.linqs.psl.database.Partition, org.linqs.psl.database.Partition...) methods. A Database writes to and reads from one Partition of a DataStore and can read from additional Partitions. The write Partition of a Database may not be a read (or write) Partition of any other Database managed by the datastore. A Database can be instantiated with a set of StandardPredicates to close. (Any StandardPredicate not closed initially remains open.) Whether a StandardPredicate is open or closed affects the behavior of ReadableDatabase.getAtom(Predicate, Constant...).

Retrieving GroundAtoms

A Database is the canonical source for a set of GroundAtoms. GroundAtoms should only be retrieved via ReadableDatabase.getAtom(Predicate, Constant...) to ensure there exists only a single object for each GroundAtom from the Database. A Database contains an AtomCache which is used to store GroundAtoms that have been instantiated in memory and ensure these objects are unique.

Persisting RandomVariableAtoms

A RandomVariableAtom can be persisted (including updated) in the write Partition via commit(RandomVariableAtom) or RandomVariableAtom.commitToDB().

Querying for Groundings

DatabaseQueries can be run via ReadableDatabase.executeQuery(DatabaseQuery). Note that queries only act on the GroundAtoms persisted in Partitions and GroundAtoms with FunctionalPredicates.

Field Summary

Fields

Modifier and Type	Field and Description
protected AtomCache	cache The atom cache for this database.
protected boolean	closed Keeps track of the open / closed status of this database.
protected DataStore	parentDataStore The backing data store that created this database.
protected List<Integer>	readIDs
protected List<Partition>	readPartitions The partition IDs that this database reads from.
protected int	writeID
protected Partition	writePartition The partition ID in which this database writes.

Constructor Summary

Constructors

Constructor and Description
Database(DataStore parent, Partition write, Partition[] read)

Method Summary

Modifier and Type	Method and Description
void	commit(RandomVariableAtom atom) Persists a RandomVariableAtom in this Database's write Partition.
int	countAllGroundAtoms(StandardPredicate predicate) Get a count of all the ground atoms for a predicate.
abstract int	countAllGroundAtoms(StandardPredicate predicate, List<Integer> partitions)
int	countAllGroundRandomVariableAtoms(StandardPredicate predicate) Get a count of all the ground RandomVariableAtoms for a predicate.
List<GroundAtom>	getAllGroundAtoms(StandardPredicate predicate) Fetch all the ground atoms for a predicate.
abstract List<GroundAtom>	getAllGroundAtoms(StandardPredicate predicate, List<Integer> partitions)
List<ObservedAtom>	getAllGroundObservedAtoms(StandardPredicate predicate) Fetch all the ground ObservedAtoms for a predicate.
List<RandomVariableAtom>	getAllGroundRandomVariableAtoms(StandardPredicate predicate) Fetch all the ground RandomVariableAtoms for a predicate.
abstract GroundAtom	getAtom(StandardPredicate predicate, boolean create, Constant... arguments)
DataStore	getDataStore()
List<Partition>	getReadPartitions()
Partition	getWritePartition()
boolean	hasAtom(StandardPredicate predicate, Constant... arguments) Check to see if a ground atom exists in the database.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.linqs.psl.database.ReadableDatabase

executeGroundingQuery, executeQuery, getAtom, isClosed

Methods inherited from interface org.linqs.psl.database.WritableDatabase

close, commit, commit, deleteAtom, moveToWritePartition

Field Detail

parentDataStore

protected final DataStore parentDataStore

The backing data store that created this database. Connection are obtained from here.

writePartition

protected final Partition writePartition

The partition ID in which this database writes.

writeID

protected final int writeID

readPartitions

protected final List<Partition> readPartitions

The partition IDs that this database reads from.

readIDs

protected final List<Integer> readIDs

cache

protected final AtomCache cache

The atom cache for this database.

closed

protected boolean closed

Keeps track of the open / closed status of this database.

Constructor Detail

Database

public Database(DataStore parent,
                Partition write,
                Partition[] read)

Method Detail

getAtom

public abstract GroundAtom getAtom(StandardPredicate predicate,
                                   boolean create,
                                   Constant... arguments)

hasAtom

public boolean hasAtom(StandardPredicate predicate,
                       Constant... arguments)

Description copied from interface: ReadableDatabase

Check to see if a ground atom exists in the database. This looks for a real ground atom and ignores the closed-world assumption. If found, the atom will be cached for subsequent requests to this or getAtom().

Specified by:

hasAtom in interface ReadableDatabase

countAllGroundAtoms

public int countAllGroundAtoms(StandardPredicate predicate)

Description copied from interface: ReadableDatabase

Get a count of all the ground atoms for a predicate. By "ground", we mean that it exists in the database. This will not leverage the closed world assumption for any atoms.

Specified by:

countAllGroundAtoms in interface ReadableDatabase

countAllGroundAtoms

public abstract int countAllGroundAtoms(StandardPredicate predicate,
                                        List<Integer> partitions)

countAllGroundRandomVariableAtoms

public int countAllGroundRandomVariableAtoms(StandardPredicate predicate)

Description copied from interface: ReadableDatabase

Get a count of all the ground RandomVariableAtoms for a predicate. By "ground", we mean that it exists in the database. This will not leverage the closed world assumption for any atoms.

Specified by:

countAllGroundRandomVariableAtoms in interface ReadableDatabase

getAllGroundAtoms

public List<GroundAtom> getAllGroundAtoms(StandardPredicate predicate)

Description copied from interface: ReadableDatabase

Fetch all the ground atoms for a predicate. By "ground", we mean that it exists in the database. This will not leverage the closed world assumption for any atoms.

Specified by:

getAllGroundAtoms in interface ReadableDatabase

getAllGroundAtoms

public abstract List<GroundAtom> getAllGroundAtoms(StandardPredicate predicate,
                                                   List<Integer> partitions)

getAllGroundRandomVariableAtoms

public List<RandomVariableAtom> getAllGroundRandomVariableAtoms(StandardPredicate predicate)

Description copied from interface: ReadableDatabase

Fetch all the ground RandomVariableAtoms for a predicate. By "ground", we mean that it exists in the database. This will not leverage the closed world assumption for any atoms.

Specified by:

getAllGroundRandomVariableAtoms in interface ReadableDatabase

getAllGroundObservedAtoms

public List<ObservedAtom> getAllGroundObservedAtoms(StandardPredicate predicate)

Description copied from interface: ReadableDatabase

Fetch all the ground ObservedAtoms for a predicate. By "ground", we mean that it exists in the database. This will not leverage the closed world assumption for any atoms.

Specified by:

getAllGroundObservedAtoms in interface ReadableDatabase

commit

public void commit(RandomVariableAtom atom)

Description copied from interface: WritableDatabase

Persists a RandomVariableAtom in this Database's write Partition. If the RandomVariableAtom has already been persisted in the write Partition, it will be updated.

Specified by:

commit in interface WritableDatabase

getDataStore

public DataStore getDataStore()

Returns:

the DataStore backing this Database

getReadPartitions

public List<Partition> getReadPartitions()

getWritePartition

public Partition getWritePartition()