Object-Orientation FAQ

20 Ode (C++ OODB)

Note: Ode version 3.0 is now available.
What: Ode Release 1.1
From: nhg@research.att.com
Ode is an object-oriented database based on the C++ database model. The
primary interface to Ode is the database programming language O++ which is
based on C++.
Ode 1.1 is now available to Universities.  This is a beta release.  The
current version of Ode runs on Sun (Sparc) workstations and users must have
C++ release 2.0 or a later release.  If you are interested in using Ode and
giving us feedback on your experience with Ode, please send me mail with the
appropriate information.
Narain Gehani
AT&T Bell Labs 3D-414
600 Mountain Ave
Murray Hill, NJ 07974
From: thssamj@iitmax.iit.edu (Aditya M. Jani)
Subject: *Announcement* UserGroup for ODE (OODBMS from AT&T)
Organization: Illinois Institute of Technology, Chicago
Date: Fri, 25 Jun 93 17:27:53 GMT
                    Ode Object database v2.0
Ode 2.0 is available via ftp from research.att.com.
Here is a sample session showing how to retrieve Ode 2.0
which is kept in the directory
as a compressed tar file named
First create the directory on the local machine
where ode is to be installed, e.g.,
mkdir ode
cd ode
Retrieve the compressed tar Ode file using ftp into
as illustrated below.
Then uncompress it
uncompress 2.0.oppbin.tar.Z
and unbundle it
tar xvf 2.0.oppbin.tar
Next see file README, fix install file, and run install
Sample ftp session
$ ftp research.att.com
Connected to tcp!!1390.
220 inet FTP server (Version 4.271 Fri Apr 9 10:11:04 EDT 1993) ready.
Name (research.att.com:smith): anonymous
331 Guest login ok, send ident as password.
Password: smith@hostname
230 Guest login ok, access restrictions apply.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> cd dist
250 CWD command successful.
ftp> cd ode2.0
250 CWD command successful.
ftp> get 2.0.oppbin.tar.Z
200 PORT command successful.
150 Opening BINARY mode data connection for 2.0.oppbin.tar.Z (2762525
226 Transfer complete.
2762525 bytes received in 1.6e+02 seconds (16 Kbytes/s)
ftp> quit
221 Goodbye.
                              Available Now!
                                 Ode 2.0
                       An Object-Oriented Database
       C++ Compatible, Fast Queries, Complex Application Modeling,
       Multimedia Support, and more
       Ode 2.0 is now available to Universities.  Users who currently
       have Ode 1.1 will be automatically sent a tape with Ode 2.0.
       There is no charge for Ode.  However, AT&T requires the signing
       of a non-disclosure agreement.
       The Ode object database is based on the C++ object paradigm.
       Ode  uses  one  integrated data model (C++ classes) for both
       database and general purpose manipulation.  The Ode database
       is   defined,   queried  and  manipulated  in  the  database
       programming language O++, which provides simple and  elegant
       facilities for manipulating the database.
       O++  is  an  upward-compatible  extension  of  C++.   A  few
       facilities have been added to C++ to make it into a database
       programming language.  C++ programmers can learn  O++  in  a
       very short time.
       O++ programs can be compiled with C++ programs thus allowing
       the use of existing C++ code.
       Ode offers a simple and elegant notion of persistence  which
       is   modeled  on  the  ``heap''.   Specifically,  memory  is
       partitioned into volatile and persistent.  Volatile  objects
       are   allocated   in   volatile   memory  (stack  or  heap).
       Persistent objects are allocated  in  persistent  store  and
       they  continue  to exist after the program that created them
       has terminated.
       An Ode database is a collection of persistent objects.  Each
       object  is  identified  by  a  unique  object  id  (i.e.,  a
       persistent pointer,  or  to  be  precise,  a  pointer  to  a
       persistent object).
       The database programming language  O++  provides  facilities
       for   creating  and  manipulating  the  Ode  database.   For
       example,   O++   provides    facilities    for    specifying
       transactions,  creating and manipulating persistent objects,
       querying the database, creating and manipulating versions.
       Some  important  characteristics   of   an   object-oriented
       database are:
          + data is stored as objects,
          + data  can  be  interpreted  (using  methods)  only   as
            specified by the class designer,
          + relationship  between  similar  objects  is   preserved
            (inheritance), and
          + references between objects are preserved.
          + Speed: Queries can  be  faster  because  joins  (as  in
            relational  databases)  are  often not needed.  This is
            because an object can be retrieved directly  without  a
            search, by following object ids.
          + No impedance mismatch: The same data model is  used  by
            both   the   database   programming  language  and  the
            database;  it  is  not  necessary  to  do  any   format
            conversions  when  reading  the data from disk and when
            storing the data on disk.
          + Programmers  need  to  learn   only   one   programming
            language:  The  same  programming  language is used for
            both data definition and data manipulation.
          + Complex applications: The full power  of  the  database
            programming language's type system can be used to model
            the data structures of a complex  application  and  the
            relationship between the different data items.
          + Multimedia  applications:  The   semantic   information
            stored  in  the  database  (class  methods) facilitates
            correct  interpretation  of  the  data.   This  reduces
            application complexity since applications do no have to
            be responsible for the correct interpretation of data.
          + Versions: Object-oriented databases  typically  provide
            better support for versioning.  An object can viewed as
            the set of all its versions.  Also, object versions can
            be treated as full fledged objects.
          + Triggers  and  constraints:  Object-oriented  databases
            provide systematic support for triggers and constraints
            which are the basis of active databases.
       Finally, most, if not all, object-oriented applications that
       have  database  needs  will  benefit  from  using an object-
       oriented database.  Specifically, C++ applications that have
       database needs will benefit from using Ode.
         1.  Ode is C++ based and compatible with C++.
         2.  The  Ode  object   database   provides   four   object
             compatible  mechanisms  for  manipulating and querying
             the database: O++, OdeView, OdeFS, and CQL++:
                + O++ is a database programming language  based  on
                  C++.   O++  is  upward compatible with C++ and it
                  makes minimal  changes  to  C++.   O++  offers  a
                  simple and elegant notion of persistence which is
                  modeled on the ``heap''.  O++ provides facilities
                  for querying the database, and a variant of other
                + OdeView is a graphical X-based interface  to  the
                  Ode database.
                + OdeFS is a  file  system  interface  to  the  Ode
                  object  database.   OdeFS  allows  objects  to be
                  treated and  manipulated  like  files.   Standard
                  commands  such as rm, cp and mv and tools such as
                  vi and grep can be used to manipulate objects  in
                  the database.
                + CQL++ is a C++ variant  of  SQL  for  easing  the
                  transition  from  relational databases to object-
                  oriented databases such as Ode.
             Currently, only O++ is shipped with Ode 2.0.  A  beta-
             test version of OdeFS is available upon request.
         3.  Ode supports large objects  (these  are  critical  for
             multi-media    applications).    Ode   provides   both
             transparent access for large objects and a  file  like
             interface  for  large objects.  The latter can be used
             to efficiently access and  update  parts  of  a  large
         4.  Users can create versions of objects.  Ode will  track
             the   relationship   between   versions  and  provides
             facilities for accessing the different versions.
         5.  Transactions  can  be  specified  as  read-only;  such
             transactions  are  faster  because they are not logged
             and they are less likely to deadlock.
         6.  Users   can   run    ``hypothetical''    transactions.
             Hypothetical  transaction  allow users to pose ``what-
             if'' scenarios (as often  done  with  spread  sheets).
             User  can  change  data  and  see  the impact of these
             changes without changing the database.
         7.  EOS, the storage engine of Ode, is based on a  client-
             server architecture.  Some features of EOS:
               a.  Efficient  and  transparent  handling  of  large
                   objects.  A file-like interface is also provided
                   for very large objects.
               b.  Concurrency is based on  multi-granularity  two-
                   version   two-phase   locking;  it  allows  many
                   readers and one writer to access the  same  item
               c.  Log  records  contain  only  after   images   of
                   updates,  thus making logs small.  Recovery from
                   system failures requires one scan over  the  log
                   resulting in fast restarts.
       USE MODES
       Ode supports two modes of use:
         1.  Client-server (allows multiple  users  to  access  the
             database concurrently).
         2.  Single user (improved performance  compared  to  using
             the client-server mode).
       Ode 2.0 is currently being used as the multi-media  database
       engine  for  AT&T's  Interactive TV project.  Ode 1.1 (older
       version of Ode with  limited  capabilities)  has  also  been
       distributed to 30+ sites within AT&T and 135+ universities.

This document was translated by ms2html v1.8 on 01.06.95.