Documentation

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

Either a service name e.g., "http" or a numeric port number.

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 a relation representing the complete DDL of the current DatabaseContext.

Returns the names and types of the atom functions 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.

Calculate a hash on the DDL of the current database context (not the graph). This is useful for validating on the client that the database schema meets the client's expectation. Any DDL change will change this hash. This hash does not change based on the current isomorphic schema being examined. This function is not affected by the current schema (since they are all isomorphic anyway, they should return the same hash).

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 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 to represent the number of tuples in a relation.

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

Similar to a git rebase, autoMergeToHead atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the HeadName and commits the merge. This is useful to reduce incidents of TransactionIsNotAHeadErrors but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

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.

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 reportOldExpr is evaluated in the commit's pre-change context while the reportNewExpr is evaluated in the post-change context and they are 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.