***********************************************************************
* *
* ANNOUNCEMENT *
* *
* Release of the *
* *
* ROL *
* *
* Deductive Object Base *
* *
* System *
* *
* Version 2.1 *
* *
* May 15, 1996 *
* *
***********************************************************************
This notice announces the third public release of the ROL system via
anonymous ftp.
1. What is it?
ROL (Rule-based Object Language) is a deductive object base system
developed at the University of Regina in Canada with support from
Natural Sciences and Engineering Research Council of Canada.
The ROL language effectively integrates important features in deductive
databases and object-oriented databases. It supports object-oriented
features such as object identity, complex objects, classes, class
hierarchy, multiple inheritance with overriding and blocking, and schema.
It also supports structured values such as functor objects and sets and
provides powerful mechanisms for representing both partial and complete
information on sets. It is a pure declarative query language without any
imperative parts. It builds-in important integrity constraints, such as
domain, key, referential, functional dependency, and cardinality in a
uniform framework. Furthermore, it has a logical semantics that cleanly
accounts for all of its object-oriented and value-oriented features.
2. Who may use it?
The ROL system has been used by hundreds of users world-wide for various
data and knowledge-based applications since its first public release.
Some users say that the ROL is so far the only product available that
can do everything for their research projects and it is quite easy to
learn and use.
The ROL system has also been used to teach advanced database courses on
deductive databases, object-oriented databases, and/or deductive and
object-oriented databases at a number of universities around the world.
3. What is new in 2.1:
3.1 Query result control and processing
It now provides the write command so that the user can control the
way the query results are displayed and can store the results into
a file in the way similar to C++. Here is an example:
query A[age -> B], B > 20, write(stdout, A, '[age ->', B, ']\n')
3.2 Error message reporting
If a ROL program has errors, the error messages are displayed
more meaningful so that it is easier to debug the program.
3.3 Graphical database display
If the ROL database used is a graphic database containing functor
objects such as point, line, circle, polygon, polyline, and inpicture,
then the database can be drawn on the screen by using the drawpicture
command.
3.4 X-window interface (xrol)
The user can simply use mouse to select commands rather than type
everything.
3.5 Extensive and classified examples
Significantly more examples are included in this distribution.
Some of them are contributed by ROL users world-wide.
4. What is new in 2.0
4.1 Simplify and unify user interface
4.2 Support multiple class, object, and rule updates
4.3 Support createdb, destroydb for creating and destroying all
database system files within ROL
4.4 Add the data type 'real' and the corresponding operations
4.5 Add string operations such as concat, like, substring
4.6 Add the 'in' (member-of) operation for sets
5. Features of 1.0
5.1 Effectively combining the bottom-up with top-down evaluation
strategies together to answer user queries, and return all query
results to the user at reasonable speed
5.2 Supporting higher-order features so that the user can write
more general rules and issue more general queries
5.3 Providing basic update facilities so that the user can update facts
and rules at run-time
6. Where to get it?
Release 2.1 of ROL is available via anonymous ftp from server
ftp.cs.uregina.ca/pub/rol
7. What platforms can it run on?
Hardware Operating Systems
-------- -----------------
SUN SparcStations Solaris 2.4 (both rol and xrol)
SGI Workstations IRIX 5.3 (both rol and xrol)
DEC Workstations Untrix V4.3 (only rol)
IBM PC Compatibles Linux 1.2.8 (only rol)
8. Future work
8.1 Client-Server architecture
8.2 Interface to C/C++ so that rol can call C/C++ functions and
C/C++ programs can embed ROL commands.
8.3 Efficient Object Management
8.4 Work that users suggest
9. An Example
Following is a graphic ROL program which can show the power of ROL system:
% This is a graphic database represented in ROL format.
% This database can be displayed on the screen by using the drawpicture
% command. To obtain the complete picture described by this program,
% first type query X:inpicture, then type drawpicture, as some objects
% in the picture are inferred by rules.
Schema
object
point(integer, integer) % x, y
line(point, point) isa object % from, to
circle(point, integer) isa object % center and radius
polygon(integer, {point}) isa object % location, side #, points
polyline(integer, {line}) isa object % location, side #, lines
house[ roof => polygon,
door => polygon,
windows => {polygon},
frame => polygon,
paveway => {line} ] isa object
human[ head => circle,
body => line,
arms => {line},
legs => {line} ] isa object
tree [ lines => {line} ] isa object
inpicture(point, object)
Program
% Define the graphic object standing human
% Here standing is an object identifier which identifies a graphic
% structure so that several objects in the picture can use/share the
% same structure.
standing: human[head -> circle(point(10,25),5),
body -> line(point(10,20), point(10,10)),
arms -> {line(point(10,15),point(0,10)),
line(point(10,15), point(20,10))},
legs -> {line(point(5,0), point(10, 10)),
line(point(10,10), point(15, 0))}]
% Define the graphic object working human
working: human[ head -> circle(point(10,25),5),
body -> line(point(11,20), point(13,10)),
arms -> {line(point(12,15), point(9,11)),
line(point(9,11), point(4,8)),
line(point(12,15), point(16,15)),
line(point(16,15), point(20,10))},
legs -> {line(point(13,10), point(8, 2)),
line(point(8,2), point(8, 0)),
line(point(13,10), point(18, 0))}]
% Define the graphic object bungalow house
bungalow:house[ roof -> polygon(4, {point(10,50),point(60,50),
point(70,40),point(0,40)}),
door -> polygon(4, {point(30,20), point(30,34),
point(40,34),point(40,20)}),
windows -> {polygon(4, {point(15,27), point(15,32),
point(25,32),point(25,27)}),
polygon(4, {point(45,27), point(45,32),
point(55,32),point(55,27)})},
frame -> polygon(4, {point(10,20), point(10,40),
point(60,40),point(60,20)}),
paveway -> {line(point(30,20),point(27,0)),
line(point(40,20),point(43,0))}]
% Define the graphic object twostorey house
twostorey: house[ roof -> polygon(3, {point(0,65),point(40,80),
point(80,65)}),
door -> polygon(4, {point(35,20),point(35,40),
point(45,40),point(45,20)}),
frame -> polygon(4, {point(10,20),point(10,65),
point(70,65),point(70,20)}),
windows -> {polygon(4,{point(15,30), point(15,40),
point(30,40),point(30,30)}),
polygon(4,{point(50,30), point(50,40),
point(65,40),point(65,30)}),
polygon(4,{point(15,50), point(15,60),
point(30,60),point(30,50)}),
polygon(4,{point(50,50), point(50,60),
point(65,60),point(65,50)}),
polygon(4,{point(35,50), point(35,60),
point(45,60),point(45,50)})},
paveway -> {line(point(35,20),point(32,0)),
line(point(45,20),point(48,0))}]
% Define the graphic object pine tree
pine:tree[ lines -> {line(point(18,0),point(18,20)),
line(point(0,20),point(36,20)),
line(point(0,20),point(18,55)),
line(point(18,55),point(36,20))}]
maple:tree[ lines -> {line(point(10,0),point(10,30)),
line(point(0,25),point(10,15)),
line(point(10,15),point(20,25))} ]
% Draw initial humans
inpicture(point(50,215), standing)
inpicture(point(110,215), working)
% Draw initial houses
inpicture(point(50,220), bungalow)
inpicture(point(400,220), twostorey)
% Draw an initial tree
inpicture(point(10,235), pine)
% Draw the road
inpicture(point(10,220), line(point(0,0), point(640,0)))
inpicture(point(0,210), line(point(0,0), point(630,0)))
% Draw the Sun
inpicture(point(500,500), circle(point(10,20), 20))
% Draw the mountain
inpicture(point(100,300),
polyline(2,{line(point(0,0),point(150,150)),
line(point(150,150), point(300,0))}))
% Draw the garden
inpicture(point(50,100), polygon(4,{point(0,0), point(50,50),
point(500,50), point(550,00)}))
% Draw initial trees arround graden
inpicture(point(120,140), maple)
inpicture(point(90,110), maple)
% Draw the rest humans with rules
inpicture(point(X,Y), Z) :- inpicture(point(X1,Y), Z), Z:human,
X = X1 + 180, X < 650
% Draw the rest pine trees with rules
inpicture(point(X,Y), pine) :- inpicture(point(X1,Y), pine),
X = X1 + 120, X <650
% Draw the rest maple trees with rules
inpicture(point(X,Y), maple) :- inpicture(point(X1,Y), maple),
X = X1 + 50, X <550
% Draw the rest houses with rules
inpicture(point(X,Y), bungalow) :- inpicture(point(X1,Y), bungalow),
X = X1 + 120, X <400
inpicture(point(X,Y), twostorey) :- inpicture(point(X1,Y), twostorey),
X = X1 + 120, X <550
--
--------------------------------------------------------------------------
Dept of Computer Science Tel: (306) 585-4700 (O)
University of Regina (306) 789-9823 (H)
Regina, Saskatchewan Fax: (306) 585-4745
Canada S4S 0A2 WWW: www.cs.uregina.ca/~mliu
--------------------------------------------------------------------------