This version of the TR implmentation runs on XSB Prolog. To run the Prolog
interpreter, perform the Unix shell command:
At the XSB prompt, consult the main module and initialise the TR implementation
by calling "init".
XSB Version 1.4.1(94/11/21)
[sequential,single word, optimal mode]
A transaction program consists of a set of transaction rules and declaration
statements. To input a transaction base from a file tr_file, perform the
The transaction base in tr_file will pass through a parser and
be compiled into a set of Prolog rules. The compiler stores the rules into
a new file with suffix _tran(i.e. tr_file_tran in this
case) and loads them into the Prolog database.
The directive loadtrans/1 loads a transaction base. To load
database, perform the following directive:
The database in the file db_file contains a set of declaration statements,
database rules and tuples. Note that database rules and transaction rules
are treated differently.
Transaction Rules and Database Rules
Like Prolog rules, a transaction rule consists of two parts: a rule head
and a rule body.
Head <- Body.
where Head is an atomic formulae, and Body is a sequence
of transaction actions (or queries) connected by serial conjunction
For example, suppose the transaction base consists of the following
Then, the transaction query '|?- trans add(10).' would create 10
tuples (p(1) to p(10)) in the database.
add(N) <- N>0 sc N1 is N-1 sc create(p(N)) sc add(N1).
On the other hand, a database rule has the same format as a Prolog rule, i.e.
Head :- Body.
The body of a Prolog clause can be a database predicate or a
conjunction of database predicates.
Note that predicates in the body of a transaction rule can define in
the database, the transaction base or the transition base, but predicates
in the body of a database rule can only be defined in the database.
To distinguish a transaction from a Prolog query, the user must put the
transaction query as the argument of the Prolog predicate trans/1.
For simplicity, "|?- " is a Prolog query prompt, and "|?- trans
" is a transaction prompt.
For example, suppose the transaction base and database contain the following:
transaction base database
Then, |?- p(X). outputs X=2 only but |?- trans p(X).
outputs X=1 and X=2. So, rules in transaction base are
invisible to Prolog query.
A transaction query is a sequence of goals (or updates). The serial conjuction
connective is denoted by sc. For example,
|?- trans p(1) sc create(q(2)).
means if p(1) is in the database(or transaction base), create a tuple q(2)
to the database.
Standard TR Predicates
Database atoms represent tuples in a relation. Each relation has its
own key. Each key determines a unique value. A declaration statement for
a relation should be made before attempting to access it. The
statement declares the arity of the relation, its key, and indexes. The format
of a declare statement is:
key NKey size S indexing IList
The statement declares a database relation with name Name and
number of arguments NArgs. The first NKey arguments of the
relation are the key, which uniquely identifies the values
of the remaining arguments. The remaining part of the declaration statement
is indexing specifications. The system would create
a hash table with S entries for the arguments listed in IList
. Note that in most Prologs other than XSB, this part of a declaration
is neglected, because most Prolog interpreters do not allow user-defined indexing on predicates.
In the declaration statement, apart from the relation name and arity,
if any of the remaining declaration is missing, the program uses default
- If the key field is missing, the program uses
the whole tuple as the key.
- If the size and indexing fields are missing, the program does
not define any special indexing.
- If the indexing field is missing, the program defines
a hash table with S entries on the arguments of
After declaration, a relation can be accessed through queries and updates.
There are three types of simple updates: create, destroy and set; and three
types of bulk updates: bulk insert, bulk delete and assignment.
The following examples use declarations of p/1 key 1,
and q/2 key 1.
- Inserts the tuple Tuple into database. The tuple specification
should have been declared in advance. The predicate also fails if
the key of Tuple is already in the database. In other word, the
key of tuple has already assigned a value. Note that all variables
in Tuple should have been unified before being created. For
example, trans create(p(1)) sc create(p(2)) creates two
tuples, p(1) and p(2) to the database, but trans
create(q(1,1)) sc create(q(1,2)) fails.
- Removes the entry Tuple from database. The process fails if
Tuple was not in the database. Arguments of Tuple can be
uninstantiated because the execution would unify the variables by
choosing tuples in database. For example, trans destroy(p(1))
deletes p(1) from database; trans destory(q(X,Y)) deletes
one of the q(X,Y) tuple from database.
- Change the value of the key identified by Tuple. The key of
Tuple should not be the tuple itself, otherwise, no value of
the key can be set. For instance, if q(1,1) is in the database,
trans set(q(1,2)) succeeds, but if q(2,2) is not in the
database, trans set(q(2,3)) fails.
- adds all tuples to ToTuple which satisfy the condition $Cond$.
Also, it never fails except ToTuple is not declared.
- destroys all tuples satisfying Dtuple. Again, it never fails
unless Dtuple is not declared.
- ToTuple := Cond
- deletes all tuples in the relation of ToTuple and overwrites
them with those satisfies the condition Cond. For instance,
p(X) := q(X,Y) selects the first elements of q(X,Y),
and then put in the predicate p(X). So, if the database contains
q(1,1), q(2,2), then p(1) and p(2) are created. Note
that Cond is a database formula and the assignment searches over
the database only.
Loop and Selection
There are two types of loop defined: while loop and and for loop.
The simplest selection statement is a if-then-else statement. It has the
- [with VList] while Cond
- iterates Actions repeatedly until Cond fails.
The list VList contains the variable names which have
been unified and cannot be used as free variable inside the
- [with VList] for Vars
in Cond do Actions
- executes Actions for all sets of distinct variables
denoted by Vars chosen from Cond.
Some Prolog interpreters have the directive if/3 which performs
- if Cond then Action1 else
- exectes Action1 if Cond is true or
executes Action2 otherwise.
You can take a look of a simple tutorial