*   OODBMS - object-oriented database management 
             system
*   ORDBMS - object-relational database management
             system

*   an object DBMS -- should be a database of objects

potential OODBMS advantages:
*   would be great if it could be integrated
    with the OO programming language
    *   because then the programmer could get
        object persistence without even having
        to learn SQL/database language

*   automatic method storage/retrieval

*   user-defined types

*   complex data can be readily processed
    *   you aren't limited to 1:1, 1:N, N:M --
        no need for foreign keys, primary keys,
	etc.

    *   (related via superclass/subclass)
    *   (can relate data more richly than you can
        with relations...)
*   automatic persistent object id's

OODBMS potential disadvantages
*   requires object-oriented programming

*   little existing data already in object form

*   nonexistent/poor query and reporting tools
*   limited concurrency control and transaction
    management (currently)
*   unproven performance (currently)
*   substantial change and learning required
    (depending on one's starting point...)

A few additional notes:
*   OODBMS standards are being worked on...
    *   SQL3 - attempts to extend the SQL standard
        to include support for object-oriented
	database management;

    *   ODMG - from a consortium of object database
        vendors -- (heritage: object programming!)
        *   trying to define interfaces for object
            data management products;

*   the "Manifesto" paper gives its opinion about
    the MINIMUM features it believes a system must
    support to TRULY call itself an OODBMS:
    LIKE MODERN RDBMS...
    *   persistence
    *   secondary storage management
    *   concurrency control
    *   recovery
    *   ad-hoc query facility
        ("high-level, efficient, and application 
         independent")

    LIKE IS EXPECTED IN AN OO-PARADIGM...
    *   should support complex objects
    *   should support object identity
        ("objects can be uniquely identified even
          if their data completely matches another
	  object")
    *   should support encapsulation
        ("an object will encasulate both a program
          and its data")
    *   should support types or classes
        (either Smalltalk or C++/Java objects)
    *   should support inheritance!
    *   should support overriding, overloading,
        and polymorphism (late binding)

    *   should support extensibility

The Manifesto paper also lists some optional-but
desirable features...for example,
*   multiple-inheritance
*   type-checking and type-inferencing
*   distributed
*   version-control