From: jack@odi.com (Jack Orenstein)
Subject: Re: OO databases OBJECTSTORE vs ONTOS
Organization: Object Design, Inc.
Date: Wed, 22 Jul 92 14:14:51 GMT

In article <1992Jul21.074743.23542@cbfsb.cb.att.com> nh@cbnewsg.cb.att.com (nicholas.hounsome) writes:

   From article <1992Jul20.173530.28999@athena.mit.edu>, by berczuk@space.mit.edu (Steve Berczuk):
   > 
   > Does anyone out there have any experiences with either Ontos or
   > ObjectDesign;'s object store as a database for C++ objects? (even better, has anyone done any comparisions?)
   > 

   I am currently doing a comparison - I have tried ObjectStore but I 
   have not received a copy of ONTOS yet so I probably
   know no more than you.

I'm an employee of Object Design, Inc.

   > what I know comparison wise (so far) is this (please correct me if I misstate anything):
   > 
   > *) Ontos seems to support a richer (and more SQL like if that is worth anything) query facility.

   That is my impression too. ObjectStore queries appear to be there 
   for performance reasons only - to gain the advantage of indexing. They
   are nothing like SQL. ObjectStore is very definitely for programmers
   to make objects persistent rather than for ad hoc queries.

These are not mutually exclusive. ObjectStore is aimed at
programmers developing applications that manipulate both
transient and persistent objects. There is a non-procedural
query language that can be used from the host programming
language, (using our compiler or 3rd-party compilers), as well
as from a browser.

The ObjectStore query language is not SQL, because SQL assumes a
first normal form (1NF) schema, while object databases are
almost never 1NF. The query language does some things that SQL
cannot, (e.g.  support for user-defined types and functions,
optimization of queries for some user-defined functions, support
for non-first-normal-form constructs, queries over transient
data), and vice versa, (e.g. dynamic type creation).

I agree with the statement that ObjectStore is "for
programmers". So is SQL -- relational DBMS applications are
built in a mixture of SQL and host language. ObjectStore
simplifies this process by extending the type system of the host
language to the database. This eliminates the need to translate
back and forth between relational and host language type
systems.

   > *) Ontos is inheritance based while Objectstore is not.

   I think that this is true. You can make anything persistent in
   ObjectStore.

Correct. Persistence is treated as a storage class, rather than
as an inherited behavior.

   > *) Object store has less effect on your code but is based on  language extensions

   You do not have to use the extensions. Talking to people on the 
   course I went on most of them that either do not or will not use
   the extensions. If you do not use the extensions then the only 
   intrusion on your nonpersistent  C++ is:
	   a) stuff to handle database roots (entry points)
		   this can be handled by macros.
	   b) transaction handling.
		   this is obviously unavoidable.
	   c) stop gap exception handling macros pending
		   cfront support.
	   d) you must use ObjectStore collections if you want queries.
	   e) you must change all new calls for persistent allocation
		   Less trouble than you might think .

   Of these only (e) is realy noticeable.

To clarify: Some features of ObjectStore are supported as both
language extensions, (available through a compiler provided as
part of ObjectStore) and function-call interfaces. Other
features are supported through a function-call interface only
(because a language extension doesn't buy any simplification).
All features are available through all supported interfaces.


Jack Orenstein
Object Design, Inc.


-- This is not a disclaimer --