Questions persist about the user value of universal databases

Several have forged so-called universal database managers by blending the object and
relational models. As with any big change, agencies should approach this Swiss army
knife-like tool with caution.

Everyone remembers that databases didn't just snap into client-server or intranet
environments without a lot of planning, testing and late nights. Although the advantages
of universal databases sound compelling, questions persist as to their value for most
information users.

The striking thing about universal databases is that they mix object and relational
data on a single resource server.

In the relational model, data exists as two-dimensional tables and nothing but tables.
But object-oriented databases can form complex groupings of data or binary information.
The application logic, known as methods, exists with and controls access to the data.

Objects let database architects model complex structures and binary information such as
multimedia or repository data. Object databases support the OO concepts of inheritance,
encapsulation and polymorphism, which means you can reuse the data structures and
behaviors.

So far, however, OODBMSes have been relegated to special-purpose applications.
Developers view the products now available as rather high-risk, so most client-server and
intranet and Internet applications still stick pretty closely to the leading RDBMSes from
Oracle Corp., Sybase Inc. and Informix Software Inc. of Menlo Park, Calif.

Support for the object model varies among universal database vendors. So far, no one
vendor supports all the pure OO features such as encapsulation, inheritance, pointer
navigation and tight integration with OO tools and languages such as C++.

None provide easy storage for persistent objects--although you can use middleware to
store persistent objects in conventional RDBMSes. The fact is, even if data is presented
as objects, the underlying structure remains tables and columns.

Object purists point out that universal databases must decompose objects into
relational tables for storage, then translate them back into objects to present to the
application. This multiple translation degrades performance. However, muscle-bound servers
can relieve such performance problems.

Various vendors refer to universal databases as universal servers or object-relational
databases. What they mean is that their relational database servers' capabilities have
been extended to store and manage objects or other data types within the same engine.

Informix-Universal Server, IBM Corp.'s DB2 Universal Database and Oracle's Oracle8 are
all universal databases. Sybase puts in layers of middleware to make relational data
appear as objects.

Oracle8 is the king of the hill in universal databases. However, Oracle is releasing
only bits and pieces of the promised universality in successive releases.

The reason for this is Oracle's concurrent development of the Network Computing
Architecture, based on the Common Object Request Broker Architecture (CORBA).

NCA uses extensible components known as cartridges, built by Oracle partners. Oracle
itself makes the components at the middleware and engine layers. Users are promised
"object views" of data across the Oracle universal database as well as existing
relational-only Oracle databases.

Oracle8 supports a client-object cache with object navigation via references, where the
object type translator links the database object to a programming language such as C.

Oracle8 supports objects in the type system as well as collection and reference types.
Methods and object types are explicitly associated. But Oracle8 does not yet support
abstract data types, although it does support scalar user-defined functions and
user-defined index structures with multiple attributes and parallel execution.

An optimizer can link cost and statistical information to these user-defined functions.
Binary large objects, or BLOBs, can be stored inside or outside the Oracle8 database, and
developers can create user-defined functions and stored procedures using PL/SQL or C++.

DB2 Universal Database, scheduled for delivery in the next several months, is probably
the most underrated of the universal databases so far.

This is an amalgam of IBM's DB2 Common Server and DB2 Parallel Edition. It has new
features such as file links to manage data external to the engine.

A DataJoiner middleware layer provides heterogeneous access to different data types.
The idea is to let DataJoiner use the DB2 Universal Database object-relational extensions.

IBM is working on an object layer component known as Client Object Support, which will
give a single logical view of data, cache manager and OO languages, while keeping
transaction consistency.

Client Object Support most likely will be DB2's route into distributed objects under
CORBA and Microsoft Corp.'s Distributed Component Object Model.

DB2 Universal Database can deal with opaque abstract data types and Object Linking and
Embedding objects. User-defined functions written in C++, C, Microsoft Visual Basic or
Java support overloading and parallel execution.

A special-purpose indexing mechanism works for all data types. Future plans call for
user-defined index structures. The rules-based optimizer now in DB2 is going through a
change for DB2 Universal Database to let developers add rules. Large objects can be stored
inside the database or through linked external files.

Informix-Universal Server resulted from grafting Illustra Information Technologies
Inc.'s object capabilities onto the Informix relational database engine. Although this was
a tough job, Informix-Universal Server is now available for 10 platforms.

It combines OnLine 7.2, the DataBlade application programming interface from the
Illustra Server and Structured Query Language 3 extensions. The Informix product supports
extensible systems of distinct types, opaque abstract data types, row types and collection
types. And it allows single inheritance via named row types.

User-defined functions include overloading and parallel execution of functions on
symmetric multiprocessing platforms. An extensible indexing system allows user-defined
index structures, and an extensible optimizer makes it possible to integrate new index
structures and custom access methods.

Developers can store large objects inside the database as pointers to external files.
The extensible language support lets them create user-defined functions and stored
procedures written in SQL, C or Java.

The DataBlades, from several third-party developers, are simply extensions that
represent an application domain integrated with the core Informix server through a
call-level interface. DataBlades make up the predefined extension capability of
Informix-Universal Server.

Developers can deal with the different data types in Informix's NewEra development
environment. Data Director, a new client engine, integrates with third-party development
tools for complex connections between the data-aware controls and the Universal Server
data.

Sybase lags behind the other three companies, but it has begun to define a strategy for
extensible data management through its Adaptive Server Architecture. This emphasizes
component-based application development and Web-enabled and distributed technology such as
Java, ActiveX and CORBA.

Toward the end of this year, Sybase is looking to provide most of its object support
through middleware layers. That middleware includes the Jaguar Component Transaction
Server, which will access relational and object data through front-end development tools
such as Sybase's PowerBuilder.

At the engine level, Sybase is merging the OmniConnect distributed query services into
the database engine, known as Adaptive Server. The idea is for all Sybase servers
eventually to implement common language processors, security services, messaging and
replication servers, administrative services and a component integration layer.

Sounds great. But it's too early to tell how well these products will work in common
environments. Most are in late beta versions or early release. And most applications have
yet to exert object-relational powers on a large scale.

It's pretty certain these new products can be layered onto most federal database
environments, but when should that happen?

Chances are if you're using an RDBMS, it integrates well with the current crop of
development tools.

No one can say the same yet for OO database systems.

It's going to take time for the tool vendors to get around to optimizing their products
for universal databases, and before they do, there will be a certain amount of risk in
using these products' object extensions.

Applications that will benefit the most from universal servers are those that store
complex data, such as repositories.

David S. Linthicum is a client-server expert with more than 15 years' experience.