This notice announces the public release of the ROL system version 2.2
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
definition. It also supports structured values such as functor objects
and sets and provides powerful mechanisms for representing both partial
and complete information about 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. It is best suited for advanced database applications.
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. Where to get it?
Release 2.2 of ROL is available via anonymous ftp from the server
ftp.cs.uregina.ca/pub/rol
It is also available from its World Wide Web home page at
http://www.cs.uregina.ca/~mliu/ROL/
4. What platforms does it run on?
It runs on the following platforms:
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)
5. What is new in 2.2:
5.1 Schema, fact, and rule queries in addition to object queries
The ROL system now extends the query command to support schema,
fact and rule queries.
5.2 Meta database management and new createdb, destroydb, and open
commands
The ROL system now keeps track of all databases existing in the
system.
The database can only be created with the createdb command
rather than the open command.
The open command only makes the existing database accessible.
The destroydb command destroys the specific database from
the system and from the meta database.
5.3 New insert and delete commands
The insert command can be used to insert facts, rules, and class
definitions.
The delete command can be used to delete facts, rules, and class
definitions.
5.4 Update command
The insert and delete commands can be used together
to update the attribute values of objects declaratively.
6. What is new in 2.1:
6.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')
6.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.
6.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.
6.4 X-window interface (xrol)
The user can simply use mouse to select commands rather than type
everything.
6.5 Extensive and classified examples
Significantly more examples are included in this distribution.
Some of them are contributed by ROL users world-wide.
7. What is new in 2.0
7.1 Simplify and unify user interface
7.2 Support multiple class, object, and rule updates
7.3 Support createdb, destroydb for creating and destroying all
database system files within ROL
7.4 Add the data type 'real' and the corresponding operations
7.5 Add string operations such as concat, like, substring
7.6 Add the 'in' (member-of) operation for sets
8. Features of 1.0
8.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
8.2 Supporting higher-order features so that the user can write
more general rules and issue more general queries
8.3 Providing basic update facilities so that the user can update facts
and rules at run-time
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)
Facts
% 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 twostory house
twostory: 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), twostory)
% 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)
Rules
% Draw the rest humans
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), twostory) :- inpicture(point(X1,Y), twostory),
X = X1 + 120, X <550
-------------------------------------------------------------------------------
The dbworld alias reaches many people, and should only be used for
messages of general interest to the database community.
Requests to get on or off dbworld should go to listproc@cs.wisc.edu.
to subscribe send
subscribe dbworld Your Full Name
to unsubscribe send
unsubscribe dbworld
to change your address
send an unsubscribe request from the old address
send a subscribe request from the new address
to find out more options send
help
------------------------------------------------------------------------FOOTER-