Documentation

Construct a ConnectionInfo to describe how to make the Connection. The database can be run within the current process or running remotely via distributed-process.

There are several reasons why a connection can fail.

To create a Connection to a remote or local database, create a ConnectionInfo and call connectProjectM36.

close cleans up the database access connection and closes any relevant sockets.

Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

Execute a database context IO-monad-based expression for the given session and connection. DatabaseContextIOExprs modify the DatabaseContext but cannot be purely implemented. this is almost completely identical to executeDatabaseContextExpr above

Execute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state.

Schema expressions manipulate the isomorphic schemas for the current DatabaseContext.

A trans-graph expression is a relational query executed against the entirety of a transaction graph.

After modifying a DatabaseContext, commit the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

Discard any changes made in the current Session and DatabaseContext. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.

Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

Return a Map of the database's constraints at the context of the session and connection.

Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

Returns the name of the currently selected isomorphic schema.

A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

Switch to the named isomorphic schema.

Return a relation which represents the current state of the global transaction graph. The attributes are * current- boolean attribute representing whether or not the current session references this transaction * head- text attribute which is a non-empty HeadName iff the transaction references a head. * id- id attribute of the transaction * parents- a relation-valued attribute which contains a relation of transaction ids which are parent transaction to the transaction

Returns the names and types of the relation variables in the current Session.

Returns Just the name of the head of the current disconnected transaction or Nothing.

Use this for connecting to remote servers on the default port.

Returns the transaction id for the connection's disconnected transaction committed parent transaction.

Use this for connecting to remote servers with the default database name.

Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

Use this for connecting to remote servers with the default head name.

The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

A relational expression represents query (read) operations on a database.

Database context expressions modify the database context.

Adding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr.

A relation's type is composed of attribute names and types.

Create a NodeId for use in connecting to a remote server using distributed-process.

Create a new session at the transaction id and return the session's Id.

Call createSessionAtHead with a transaction graph's head's name to create a new session pinned to that head. This function returns a SessionId which can be used in other function calls to reference the point in the transaction graph.

Discards a session, eliminating any uncommitted changes present in the session.

Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.

Used to represent the number of tuples in a relation.

Operators which manipulate a transaction graph and which transaction the current Session is based upon.

The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

Record a lookup for a specific transaction in the graph.

Used for git-style head backtracking such as topic~3^2.

Node identifier

Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

Represents a pointer into the database's transaction graph which the DatabaseContextExprs can then modify subsequently be committed to extend the transaction graph. The session contains staged (uncommitted) database changes as well as the means to switch between isomorphic schemas.

The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

The empty notification callback ignores all callbacks.

When a notification is fired, the reportExpr is evaluated in the commit's context, so that is returned along with the original notification.

Returns a listing of all available atom types.

Create a uniqueness constraint for the attribute names and relational expression. Note that constraint can span multiple relation variables.

Create a DatabaseContextExpr which can be used to add a uniqueness constraint to attributes on one relation variable.

Create a foreign key constraint from the first relation variable and attributes to the second.

Create a DatabaseContextIOExpr which can be used to load a new atom function written in Haskell and loaded at runtime.

Create attributes dynamically.

Found in data constructors and type declarations: Left (Either Int Text) | Right Int

Metadata definition for type constructors such as data Either a b.

Used to define a data constructor in a type constructor context such as Left a | Right b

The AttributeNames structure represents a set of attribute names or the same set of names but inverted in the context of a relational expression. For example, if a relational expression has attributes named "a", "b", and "c", the InvertedAttributeNames of ("a","c") is ("b").

Relation variables are identified by their names.

Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

The AttributeName is the name of an attribute in a relation.

The AtomType uniquely identifies the type of a atom.

All database values ("atoms") adhere to the Atomable typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.

Dynamically create a tuple from attribute names and AtomExprs.