ftp.pasteur.org/FAQ//ftp-pasteur-org-FAQ.zip/FAQ/object-faq/part6

Text File | 1996-04-05 | 50.9 KB | 1,241 lines

Newsgroups: comp.object,comp.answers,news.answers
Path: senator-bedfellow.mit.edu!bloom-beacon.mit.edu!spool.mu.edu!howland.reston.ans.net!newsfeed.internetmci.com!ncar!uchinews!news
From: Bob Hathaway <[e-mail]>
Subject: Comp.Object FAQ Version 1.0.9 (04-02) Part 6/13
X-Nntp-Posting-Host: ford.uchicago.edu
Message-ID: <[e-mail]>
Followup-To: comp.object
Summary: Frequently Asked Questions (FAQ) List and Available Systems For Object-Oriented Technology
Sender: [e-mail] (News Administrator)
Organization: Geodesic Systems
References: <[e-mail]>
Date: Wed, 3 Apr 1996 04:13:47 GMT
Approved: [e-mail]
Lines: 1224
Xref: senator-bedfellow.mit.edu comp.object:46933 comp.answers:17965 news.answers:68639

Archive-name: object-faq/part6
Last-Modified: 04/02/96
Version: 1.0.9

The VODAK Model Language VML  homogeneously integrates the concept of
metaclasses and the separation of types and classes with other
object-oriented concepts such as properties, methods, inheritance, and
object identity. Complex nested data structures can be defined using
the set, array, tuple, and dictionary type constructors. VML supports
its own programming language for implementing methods, specifying
transactions and an ad hoc query language.

In VML classes are used to organize a set of objects corresponding to
real world entities and relationships between them. Object types define
the structure of objects and the operations defined on these
structures.  They are associated with classes in order to determine the
structure and behavior of the class' instances. Metaclasses are first
class objects whose instances are classes. Metaclasses are associated
with three object types: an (optional) own-type extending their own
behavior, an instance-type specifying the behavior of their instances
(which are classes), and an  instance-instance-type specifying the
behavior of the instances of their instances.  Metaclasses can be
organized in an instantiation hierarchy of arbitrary depth.

This approach leads to an open, adaptable data model which provides for
the specification of additional modeling primitives at a meta layer of
the database schema. The concept of metaclasses and the separation of
classes and types allow to determine the structure and behavior of
objects and the individual inheritance behavior via semantic
relationships between arbitrary objects already at the meta layer
independently from the specifications given at the application layer
for the application specific classes.


The VODAK Transaction Model

In VODAK, we focus on two specific problems of transaction management.

1. Operations to read and edit (hyper)documents are typically complex,
interactive and of long duration. A high degree of concurrency is
required to reduce the number and length of times a transaction is
blocked.

2. A publication environment has to handle existing database systems
for using and modifying remote information and documents.  Transaction
managers of existing systems, i.e. concurrency control and recovery,
have to be integrated in a transparent way utilizing the functionality
of existing managers.

Our transaction model is based on open nested transactions. Compared to
conventional flat transactions, nested transactions allow more
concurrency and are more flexible for recovery.  A nested transaction
is a tree-like structure, dynamically built up by the call of
subtransactions until a bottom implementation level is encountered.

We extended the open nested model from a fixed calling hierarchy of
operations in a layered system (multi-level transactions) to an
arbitrary calling hierarchy of operations in an object-oriented system.
Commutativity of operations is applied to system defined VODAK methods,
and to methods of user defined object types.  For the second type of
operations, we developed a framework to specify commutativity and
inverse operations in VML.

Query Processing

Although nearly all object-oriented data models proposed so far include
behavioral aspects, most object-oriented query languages, algebras and
query optimization strategies simply adapt relational concepts since
they focus on the complex structures of objects and neglect the
behavior. We claim that this approach is not sufficient since it does
not reflect the much richer semantics methods can carry which have to
be taken into account for really efficient query processing. The quite
straightforward approach we consider is to integrate methods in an
algebraic framework for query processing and to make there partial
knowledge about methods available in the form of equivalences. We
integrate algebraic set operators with methods defined in database
schemas within an object-oriented data model. We investigate the impact
on the architecture of the query processor when the algebra becomes an
extendible component in query processing.

Multimedia Support

The V3 Video Server was built as a demonstration showing a multimedia
application developed on top of the VODAK database management system.
The V3 Video Server allows a user to interactively store, retrieve,
manipulate, and present analog and short digital video clips. A video
clip consists of a sequence of pictures and corresponding sound.
Several attributes like author, title, and a set of keywords are
annotated.

In the future, the VODAK DBMS will be enhanced with new built-in
functionality for multimedia datatypes. Therefore, existing components
of VODAK must be changed and new ones must be added to support time
dependencies, high data volumes, and user interaction.

Query Processing

Although nearly all object-oriented data models proposed so far include
behavioral aspects, most object-oriented query languages, algebras and
query optimization strategies simply adapt relational concepts since
they focus on the complex structures of objects and neglect the
behavior. We claim that this approach is not sufficient since it does
not reflect the much richer semantics methods can carry which have to
be taken into account for really efficient query processing. The quite
straightforward approach we consider is to integrate methods in an
algebraic framework for query processing and to make there partial
knowledge about methods available in the form of equivalences. We
integrate algebraic set operators with methods defined in database
schemas within an object-oriented data model. We investigate the impact
on the architecture of the query processor when the algebra becomes an
extendible component in query processing.

The VODAK Prototype

The system architecture consists of a central database environment and
several external database environments to which the user wants to have
integrated access. Each of these environments consists of an object
manager, a message handler, a transaction manager, and a communication
manager. In addition to these components an external database
environment includes a database interface module which realizes the
access to an external database system.

The DBMS components are currently built on top of DAMOKLES and will be
in the near future on top of ObjectStore.

A first version of a C++ based prototype of VODAK is available for Sun
Sparc Stations under certain conditions.  It implements all the
features specified in including e.g. metaclasses, transactions, and
remote message execution.

References

P. Muth, T. Rakow, W. Klas, E. Neuhold:  A Transaction Model for an
Open Publication Environment.  A. K. Elmagarmid (Ed.): Database
Transaction Models for Advanced Applications. Morgan Kaufmann
Publishers, San Mateo, Calif., 1992.

Wolfgang Klas, Karl Aberer, Erich Neuhold Object-Oriented Modeling for
Hypermedia Systems using the VODAK Modeling Language (VML) to appear
in: Object-Oriented Database Management  Systems, NATO ASI Series,
Springer Verlag Berlin Heidelberg, August 1993.

Karl Aberer, Gisela Fischer Object-Oriented Query Processing: The
Impact of Methods on Language, Architecture and Optimization
Arbeitspapiere der GMD No. 763, Sankt Augustin, July 1993.

T.C. Rakow, P. Muth The V3 Video Server: Managing Analog and Digital
Video Clips, Sigmod 93, Washington, DC.

For further information contact

{aberer,muth,rakow,klas}@darmstadt.gmd.de

  GMD-IPSI
  Dolivostr. 15
  D-64293 Darmstadt
  GERMANY

  FAX: [phone]


Commercial Systems
__________________

> ArtBASE  (Object-Oriented Data Model)

by:     ArtInAppleS Ltd.
        Kremelska 13
        845 03 Bratislava
        SLOVAKIA
        Phone: x42-7-362-889
        fax:   x42-7-777 779
        EMail: [e-mail]

Distributor for Germany:
        ARS NOVA Software GmbH
        Stettener Strasse 32/3
        73732 Esslingen a.N.
        Germany
        Phone: x49-711 3704001
        Fax:   x49-711 3704001
        EMail: [e-mail]

Languages: Objectworks\Smalltalk by ParcPlace Systems, Inc.

Platforms: Unix, PC Windows, Macintosh

Features:
- Fully implemented in Objectworks\Smalltalk
  (ArtBASE is delivered with source code)

- ArtBASE extents Smalltalk of persistency. Persistent objects are handled the
  same way as transient objects.

- Optimistic and pessimistic concurrency control.

- Transactions, including long lived transactions

- User concept with access restrictions

- storing of classes and methods in the database - entire applications
  may be stored in an ArtBASE database, including the data AND the
  application classes

- Currently, a single user version is available. The Distributed Multi User Server Version
  will be presented at the OOPSLA'93 at Washington D.C. in September 1993 for Unix
  environments and PCs.

- Existing applications can be turned to database applications very easily using ArtBASE


> EasyDB (Basesoft Open Systems, Sweden)

Produce EasyDB, a single or multi user distributed Object Database
Management System. Well integrated with C, C++ and Ada. Appears well
architected.

Main features include: fully distributed, multi-client, multi-server
architecture; distributed storage and access transparent to the user;
well integrated language bindings to C, C++ and Ada; multiple language
access and data independence between different programming languages;
conceptual modeling approach - intuitive and natural Data Definition
Languages, based on the well known ERA-technique combined with object
orientation where the user can choose between a graphical or a textual
notation; dynamic schema evolution; interactive ad-hoc query language;
powerful type system with possibilities to define ranges of permitted
values; in addition to conventional data types there are BYTESTREAM and
DATABASE REFERENCE (link); support for bidirectional relationships;
support for short and long transactions; support for versioning; dynamic
and static name resolution; high reliability and powerful
error/conflict/exception handling.

Customers include SAAB Aircraft, Swedish Defence Research, Ericsson
Radar, Swedish Telecom, Swedish Defence.

Popular applications areas include communications (EDI), simulation,
GIS, CASE/CAD, library and retrieval systems (reuse libraries).

Basesoft Open Systems AB
P.O. Box 1097
S-164 21 Kista
Sweden

Voice:    [phone]
Telefax:  [phone]
Email:    [e-mail]

Jaan Haabma, President


> GemStone (Formerly Servio Corporation)

The GemStone Object-Oriented Database, from GemStone Systems, Inc.

First introduced in 1987, GemStone is the oldest commercial ODBMS available
today. GemStone is particularly well suited for use in complex multi-user,
multi-platform client/server applications. It supports concurrent access
from multiple external languages, including Smalltalk (VisualWorks, Visual
Age, and Visual Smalltalk), C++ and C. GemStone also provides Smalltalk as
an internal DML, which can execute methods or entire applications in the
database.


CAPABILITIES

GemStone is a highly scalable client-multiserver database for commercial
applications. GemStone's features include:

o  Server Smalltalk -- GemStone allows database application developers to
   create classes and write methods which are stored and executed directly
   in the database. These methods can be accessed either internally, or
   from external client applications. This can significantly reduce network
   traffic and allow applications to take advantage of the compute power or
   network connectivity of the server. This also eliminates the need to
   rebuild and re-deploy applications whenever application or business
   processing rules change. This in turn allows for centralized code
   development and management, architecture-independent code that ports

o  Concurrent Support for Multiple Languages -- GemStone provides
   concurrent support for applications developed in Smalltalk, C++, or C.
   All applications, regardless of language, can have simultaneous access
   to the same database objects.

o  Flexible multi-user transaction control -- Multiple users can
   operate in the database simultaneously, with a variety of transaction
   control modes available. GemStone also provides a number of
   reduced-conflict classes which can increase system throughput
   substantially.

o  Object-level security -- Authorization control can be applied to any
   object in the database, allowing for fine tuning of object security.

o  Dynamic schema and object evolution -- GemStone supports schema
   modification through class versioning and allows full migration of
   objects between versions of their classes with a simple message send.
   Migration is fully customizable and is undoable.

o  Production Services -- GemStone delivers the full suite of features
   required in any production-ready networked database including online
   backup, rapid recovery, referential integrity, event signals, notifiers,
   and sophisticated concurrency control including optimistic, pessimistic
   and behavior based (type specific) control.

o  Scalability -- In a recent independent benchmark, GemStone scaled to
   support more than 1,000 simultaneous log-ins and 100 concurrent active
   users on a mid-sized SMP server.

o  Legacy Gateways -- GemStone incorporates gateways or data bridges
   that allow object applications to integrate legacy data, whether in SQL,
   IMS, VSAM or other formats. The level of integration between GemStone
   and legacy data and applications can range from simple query access to
   extensive read-write interoperability.

o  Developer Tools -- GemStone includes tools for debugging, browsing and
   inspecting database classes and methods. Included in this set of tools
   are browsers, inspectors, a debugger, and a code profiler for
   performance analysis.

o  Database Administration Tools -- GemStone includes a number of tools for
   general database administration, including creating new user accounts,
   assigning user and object security, managing database extents, and more.


PLATFORMS

GemStone release 4.0 and all language interfaces are available for UNIX
workstations and servers from Sun, HP, IBM, NCR, Siemens, and Sequent.
Client-only support is available in a number of languages for Windows 3.1,
Windows NT, OS/2 and Macintosh. GemStone is an active member of the Object
Management Group and the ANSI Smalltalk standardization committee. GemStone
supports ODMG, ANSI C++ and intends to comply fully with the emerging
standards.


REFERENCES

[Maier, et al. 84] D. Maier, J. Stein, A. Otis, A. Purdy, ``Development
of an object-oriented DBMS'' Report CS/E-86-005, Oregon Graduate Center,
April 86 - ACM 0-89791-204-7/86/0900-0472

R.G.G. Cattell: Object Data Management - Object-Oriented and Extended
Relational Database Systems; Addison-Wesley. ISBN 0-201-53092-9

Robert Bretl, David Maier, Allan Otis, Jason Penney, Bruce Schuchardt,
Jacob Stein, E. Harold Williams, Monty Williams. "The GemStone Data
Management System." Chapter 12 of "Object-Oriented Concepts, Databases
and Applications", by Kim and Lockovsky.


CONTACTS

==== Headquarters - Beaverton ====

GemStone Systems, Inc.
15400 NW Greenbrier Parkway
Suite 280
Beaverton, OR  97006

Tel: [phone]
Tel: [phone]
Fax: [phone]

==== San Mateo ====

GemStone Systems, Inc.
2100 Winward Way
Suite 100
San Mateo, CA  94404

Tel: [phone]
Fax: [phone]

==== Chicago ====

GemStone Systems, Inc.
8410 Bryn Mawr
Suite 400
Chicago  IL  60631

Tel: [phone]
Fax: [phone]

====  New York ====

GemStone Systems, Inc.
1120 Avenue of the Americas
4th Floor
New York  NY  10036

Tel: [phone]
Fax: [phone]

==== Dallas ====

GemStone Systems, Inc.
5001 LBJ Freeway
Suite 700
Dallas  TX  75244

Tel: [phone]
Fax: [phone]

==== Europe/UK ====

GemStone Systems, Inc.
Maple House
High Street
Potters Bar
Herts  EN6 5BS  England

Tel: [phone]
Fax: [phone]


======================
==== Distributors ====
======================

==== Germany, Austria, Switzerland ====

Georg Heeg
Objektorientierte Systemtechnologien
Baroperstrasse 337
44227 Dortmund
Germany

Tel: [phone]
Fax: [phone]

==== Scandinavia ====

WM-Data
Sandhamnsgatan 65
Box 27030
102 51 Stockholm
Sweden

Tel: [phone]
Fax: [phone]

==== Japan ====

Japan Information Processing Co., Ltd.
2-4-24 Toyo Koto-ku
Tokyo 135 Japan

Phone: [phone]
Fax:   [phone]


ABC Co., LTD Shonan System Development Div
Attn: Shoji Maekawa
271-2 Kamimachiya Kamakura-city, Kanagawa Prefecture
241 Japan.
TEL: [phone]
FAX: [phone]

==== Taiwan ====

Anco Technologies
11-1F, 76 Tun Hwa S. Road, Sec. 2
Taipei
Taiwan, R.O.C.

Tel: [phone]
Fax: [phone]

==== Mexico ====

Computadoras
Objectos y Communicaciones S.A. de C.V.
3A CDA. Porto Alegre 51
Col. San Andres Tetepilco
Mexico, D.F. 09940

Phone [phone] or [phone]
Fax   [phone]


> ITASCA

Introduction

Itasca Systems develops, markets, and supports ITASCA, a distributed
active object database management system and related tools. The initial
research work for ITASCA occurred in the Object-Oriented and Distributed
Systems Lab at the Microelectronics and Computer Technology
Corporation (MCC) in Austin, Texas. The research was known as the
ORION prototypes.

The ITASCA Distributed ODBMS is a language neutral, full-featured, active
object database that supports data access from various object
languages. ITASCA allows clients to transparently access data that is
distributed among multiple servers.  ITASCA supports full dynamic schema
modification that can be performed during any phase of the software
lifecycle.  Applications written in dissimilar and incompatible languages,
such as C++ and CLOS, share objects through ITASCA. ITASCA stores methods
inside the database, promoting reusability and maintainability.  The only
commercial ODBMS based upon the MCC Orion technology, ITASCA is considered
by many to be the most feature-rich ODBMS on the market today.

This overview describes release 2.2 of the ITASCA Distributed Object
Database Management System. It describes how ITASCA functions,
outlines its implementation features, and explains some of the system
benefits.


History of ITASCA

ITASCA is based on a series of object database research prototypes. Work
on these prototypes began in 1985 at the Microelectronics and Computer
Technology Corporation (MCC) Object-Oriented and Distributed Systems
Laboratory. MCC released the first prototype, ORION-1, in May, 1987, as
a single-user system. MCC extended ORION-1 to the ORION-1SX
prototype system and released it to the shareholder companies in April,
1988. ORION-1SX was a multi-user system with a multi-client, single
server architecture. The third prototype, ORION-2, introduced a distributed,
object-oriented architecture for a multi-user environment. MCC released
the third prototype to shareholder companies in July, 1989. ORION-2 has a
multi-client, multi-server architecture. Having met its objectives, MCC
stopped all work on ORION at that time. Over five million dollars was spent
for the three generations of prototypes.

The ITASCA product is an extension and commercialization of the ORION-2
prototype from MCC. Itasca Systems has added major enhancements and
features, improved the performance, and strengthened the code. It now runs
on UNIX systems from multiple vendors. ITASCA is an industrial-strength,
documented product, fully supported by Itasca Systems, Inc. Itasca Systems
continues to develop tools and other products to work with ITASCA.


Overview

ITASCA employs a distributed architecture with private and shared objects
spread across UNIX-based computers on a local-area network. The
ITASCA model follows the object-oriented view that uniformly models any
real-world entity as an object. Each object has a unique identifier along with
a state and behavior. Attributes represent the state of an object. Methods
(code) define the behavior of an object. A class object collects objects that
share the same set of attributes and methods. Subclasses derive from
existing classes. The resulting schema, or database definition, is a class
hierarchy. Each subclass inherits all the attributes and methods of its
superclasses. ITASCA supports multiple inheritance. A subclass may derive
from more than one superclass.

One of the breakthroughs of object-oriented technology is the reusability of
code. ITASCA allows for the active management of both reusable code and
data in an integrated system. Developers may write applications in C++,
CLOS, C or Common Lisp. This means ITASCA is language neutral. Objects
stored using one programming language can be accessed by other
programming languages. It also means an application program need not be
written in an object-oriented language.

The ITASCA database management system has features belonging to most any
database system. This includes persistent storage for data and schema,
concurrency control and locking, transaction management, multiple
security levels, and logging and recovery for both CPU and disk media
failure. Additional features of ITASCA include dynamic schema
modification, long-duration transactions, shared and private databases,
distributed version control, distributed transaction management, distributed
query management, distributed change notification, object migration, and
an extensible architecture.

Shared and private databases exist in a distributed environment in ITASCA.
The shared database is distributed across workstations (sites) in a network.
An ITASCA server controls the partition of the shared database at each site.
ITASCA clients provide transparent access to the various partitions of the
shared database. The architecture allows any number of private databases at
each distributed database site. Data can move between private and shared
databases. Private databases allow private data that is not shared with other
users of the database.

ITASCA stores the schema redundantly at each site to improve
performance. The schema storage also includes code in the form of
methods. Management of schema updates is automatic for all sites. This
includes sites that were off-line during any changes. Automatic distribution
of schema changes, including method code changes, simplifies database
administration.

ITASCA stores each instance of data in one site. The system or a user may
move the data from one site to another to improve data locality. Access to
moved data remains transparent. There is no need for a user or application
to know the specificlocation of data in the ITASCA distributed database.
ITASCA will automatically find the location of the data. This simplifies
distributed application development. The developer can rely on ITASCA
finding data in the distributed database.

No single site acts as a master site, thus ITASCA's architecture has no
single point of failure. ITASCA has neither a central data server nor a
central name server. This is important for maintaining a database system
with high availability in a networked workstation environment.

ITASCA supports dynamic schema modification to create a flexible
environment for changing or customizing a database system. Authorized
users can add and remove attributes or change the subclass/superclass
relationship at any time. Authorized users can also add or remove partitions
of the shared database at any time. All this can be done interactively without
affecting other parts of the ITASCA database at the time changes occur to
the schema. There is no need to "bring the system down" or off-load/reload
data to restructure the database. Dynamic schema modification can
significantly reduce maintenance costs. It also is useful in environments
where change to data definitions are normal or relatively frequent.

ITASCA has a sophisticated security authorization technique tied to the
class hierarchy. It supports both positive and negative authorizations at any
level in the class hierarchy. For example, granting access to all objects but
one requires only two authorizations: a global grant followed by a specific
denial. Authorization extends to classes, instances of classes, attributes,
and methods. Also, inheritance of authorization reduces the work of database
administration.

Long-duration transactions allow users to check objects out of the shared,
distributed database into their private databases. Users can then change the
objects in the private databases without affecting the shared database or
other users. These changes can be committed to the private database. Then,
at any later time, the user can check the updated object or objects back into
the shared database.

ITASCA supports version control of objects. A new version of an object
promotes the original or parent object to restrict further changes to the
parent. ITASCA also supports alternate versions such that multiple versions
can have the same parent. Promoting an object version to a released status
restricts any deletion of the object. ITASCA uses generic versions to
dynamically reference the most recent or default version of an object
without any intervention by a user or application.

Change notification in ITASCA is either flag-based or message-based.
Flag-based notification will identify an updated object upon querying the
object for such information. It is a passive notification scheme. Message-
based notification, on the other hand, is an active notification scheme. It
will execute a method (or code) upon an update or other change to an object.
Such methods can send mail messages or invoke other methods or
programs.

Memory management in ITASCA uses both page and object buffers.
ITASCA has a traditional database page buffer scheme that contains pages
with multiple objects. Desired objects move from the page buffer to an
object buffer. The object buffer then provides ITASCA with enhanced in-
memory performance because it contains only frequently-referenced
objects.


IBEX Corporation

ITASCA is a distributed active object database management system and
related tools.  The ITASCA Distributed ODBMS is a language neutral,
full-featured, active object database that supports data access from
various object languages. ITASCA allows clients to transparently access
data that is distributed among multiple servers.  ITASCA supports full
dynamic schema modification that can be performed during any phase of the
software

A point release of ITASCA (2.3.5) was delivered to customers with current
service contracts in September 1995.  Development continues with the
expectation of ODMG compliance in the next full release, scheduled for
1996.

IBEX has built its DAWN Distributed Archiving and Workflow Network class
library of methods and development tools as an application framework to
speed the development of customized solutions to enterprise-level
integration problems.  ITASCA's installed based has been largely in
manufacturing and engineering until now, but with DAWN, banking and other
services are beginning to take advantage of the products extended
functionality.  DAWN is also used to link production and front office
environments for active decision support.  The DAWN Manager Series comprises
focused applications (developed on ITASCA with DAWN), such as DAWN 9000 and
DAWN Account Manager which have an embedded Optical Character Recognition
functionality linked to the database with a customer-defined workflow.

IBEX has re-activated the ITASCA ObjectShare Library and encourages clients
to contribute reusable objects for use by registered ITASCA customers.
Several HTML and Web Browsers for the server itself are underway.

ITASCA was very well rated in a 1994 BUtlerBloor comparison of Object
Databases (the only one to receive more than one uncontested first rating
-- it got four!

Three framework papers describing IDE and CALS in more detail may be found
at Web site http://www.acq.osd.mil/cals/


IBEX Computing
International Business Park
4e Bd., Bat. Hera
74160 Archamps
France

Email: [e-mail]
Voice: [phone]
Fax:   [phone]

Web:  http://www.iprolink.ch/ibexcom/

IBEX Object Systems, Inc.  (North American office)
Minneapolis, MN  55401
U.S.A.

Voice: [phone]
Fax:   [phone]


> MATISSE

OODBMS FEATURES LIST:

An Industrial Strength Open Semantic Object Database

Performance
-       Symmetric, Fine Grain, Multi-Threaded Architecture
-       Parallel and Asynchronous Disk I/O
-       Automatic Disk Optimization through Dynamic Clustering
B
-       High Speed OLTP Environment
Reliability
-       24 Hour - Mission Critical Operation
-       Media Fault Tolerant (Object Replication)
-       Transparent On-line Recovery
Database Administration
-       Full On-line Administration (No Down Time)
-       On-line Incremental or Full Back-Up
-       Dynamically Increase Database Size -   On-line
-       Full On-line Monitoring
Data Management and Consistency
-       Dynamic Schema Evolution
-       Consistent Database Reads without Locking
-       Historical Versioning, both Schema and Data Objects
-       Built-in Enforced Referential Integrity
-       Object Level Implicit or Explicit Locking
Scalability
-       Hundreds of Concurrent On-line Users
-       Hundreds of Gigabytes Per Database
-       From Few Bytes to Four Gigabytes for Each Object
-       Up to Four Giga-objects Per Database
Object Model
-       Full Object Oriented Model
-       User Extensible Object Meta-Schema
-       Support for Complex, Highly Dynamic, Variable Sized Objects
-       Multiple Inheritance
Intelligent Objects
-       Triggers at Object, Attribute, or at Relationship Level
-       Consistency Rules at Object, Attribute, or at Relationship Level
-       Customizable Intelligent Object Indexing
-       Automatic Inverse Relationships
Open Systems
-       Open C, C++ API
-       Supports Any Commercial Development Tool and Language
-       No Proprietary Tool Required
-       Heterogeneous Cross Platform Client/Server Architecture


For additional information on MATISSE, contact
----------------------------------------------

In the UNITED STATES:
ADB Inc. (MATISSE)
1 Twin Dolphin Drive
Redwood Shores, CA  94065
U.S.A.

Voice: 1 [phone]
Fax:   [phone]
Email: [e-mail]
Web:   http://www.adb.com


In EUROPE:
ADB S.A. Inc.
12-14, rue du Fort de St Cyr
Montigny Le Bretonneux
78182 St Quentin en Yvelines
Cedex, France

Voice: 33 (1) 48 64 72 73
Email: [e-mail]
Web:   http://www.adb.fr


In ASIA:
ADB Asia / SGN
Urban Toranomon Building
1-16-4 Toranomon
Minato-ku Tokyo 105
Japan

Tel:   [phone]
Fax:   [phone]


        MATISSE TECHNOLOGY BRIEF

MATISSE was designed to have an OPEN API, and not be
tightly bound to a single language (such as C++ or Smalltalk).
MATISSE can be used effectively with C++, C, and any other language.
This allows for MATISSE to be easily integrated into almost any
user application.

MATISSE is based upon the following principles and ideals:

MATISSE is first and foremost a database, whose purpose is to
always provide information in a consistent and correct format,
insuring referential integrity amidst the most complex database
modifications.  And, to provide a set of DBA tools which meet
the challenge of managing large, complex database applications.

Production quality applications require production quality databases.
This means high reliability, high scalability, no database down
time for archival/backup/restore and 24hr/7days  per week operation.
MATISSE supports these requirements.

A flexible, intelligent meta-model architecture based upon the
principles of semantic links and object technology allows for the
most effective bases for representing and managing complex, highly
interrelated data.  The MATISSE meta-model provides built in
constraint checking, user definable constraints for triggers and
daemons, and full dynamic schema and meta-schema evolution.

Providing an architecture which is open allows for the integration
of MATISSE with any language or environment.  MATISSE is not bound
to any language.  Its 'C' API allows for its use with many
languages and environments.

The following list describes the features of MATISSE which we
believe provide the competitive advantage:
-    Mission-critical operation - 24 hour operation and fault tolerance
-    Independence from any programming language
-    Dynamic schema management and evolution
-    Flexibility of the MATISSE  meta-model
-    Historical versioning
-    Consistent reads without locking - concurrency and locking
-    Support for high level consistency and referential integrity
-    Multi-threading architecture provides for a high degree of scalability

Each of these items are described in more detail below:

Mission Critical Operation.
MATISSE is designed to support 24 hour a day / 7 day a week operation,
on multi-client / multi-server architectures.  Administration tools
offer high end features which are mandatory for legacy DB administrators.


Independence from any Programming Language.
The MATISSE client is implemented as a library of C procedures.  As a
result, any standard language can be used to develop applications on
top of MATISSE, provided that the corresponding compiler is capable
of calling external C-functions. To date, production applications have
been built on top of MATISSE using C, ADA and C++.


Dynamic Schema Management.
Schema objects can be accessed using the same API available for data
objects. The Data Definition Language is identical to the Data
Manipulation language.  Versioning is implemented for both schema
and data objects.  Thus, any running application can modify the database
schema, provided that existing instances do not become inconsistent with
that schema.  Consistency rules are checked by MATISSE.


Flexibility of the Model.
MATISSE is compliant with the IRDS standard.  Its architecture is
highly extendible at both the Schema and the Meta-Schema level.  The
MATISSE Semantic Meta-Model is not hard-coded.  It can be updated to
conform with any OMG, ANSI, ISO, ... standard that might be issued
in the future.  MATISSE can easily adapt to changing and evolving
standards, without significant effort or re engineering.


Versioning.
Using the on-line versioning mechanism, MATISSE allows any connected
client application to dynamically access any past database version which
was marked as a version to be saved.  Access can be performed without
any particular administrative operation, and concurrently with other
on-line accesses to current or other historical  versions.

Since a database version includes both data and schema objects, a
past version is always consistent, even after schema modification.  As
a past version is accessed, so to is it's schema, and even the
appropriate meta-schema associated with the accessed version.


Consistent Reads without Locking.
Using its versioning mechanism, MATISSE offers three kinds of
database access:

Typical transaction-based access: : as the
database migrates forwards, and updates are made, database access
occurs against the latest consistent database version.  A successful
transaction commit results in a new consistent version.  If explicitly
named, this version becomes a historical database version, which can
be accessed by its logical name in the future .

Historical version access: the application specifies the logical
name of the historical version to be accessed. Access is read-only,
and does not require any locking mechanism.

Current Time access: : this is a very powerful and unique feature
of MATISSE.  Any application can request the latest available consistent
database version, using a reference to current time, with no
locking overhead.  The "current time" database version is based
upon the last transaction commit, and is automatically maintained by
the database.  A "current time" database version acquires no database
locks when accessed in read-only mode, thereby significantly
reducing overhead.

Through these three access modes,  MATISSE supports on-line
transaction processing and decision support requirements concurrently
within a single application, through the use of current and historical
versions.

Support for High Level Consistency.
With MATISSE, referential integrity cannot be corrupted.  MATISSE's
Semantic Links are specialized - i.e. they are specifically
established between classes, they are directional, and, inverse links
are automatically and dynamically set by MATISSE.  As a result, a
MATISSE database understands its relationships, and fully manages
all internal consistency features, insuring that no corruption occurs.

Developers can describe very complex consistency methods and rules
using daemons and triggers.  These methods can be attached to
particular events such as, before or after creation, as well as class,
instance, attribute modification.  Daemons and triggers provide for
message propagation within your database. This results in a very
intelligent database, which can be event driven.


MATISSE Server runs on
-  Sun Sparcstation - SunOS 4.1.3
-  Sun Sparcstation - Solaris
-  VAX - VMS
-  HP9000 - HP-UX

MATISSE Client runs on
-  Sun Sparcstation - SunOS 4.1.3
-  Sun Sparcstation - Solaris
-  HP9000 - HP-UX
-  Windows NT
-  Macintosh


> NeoAccess

NeoLogic Systems

NeoLogic Systems produces NeoAccess, a cross-platform object database
engine, and NeoShare, a client/server collaborative computing engine.
NeoAccess consists of a set of C++ database and collection classes.
NeoShare extends NeoAccess to provide shared multi-user access to objects
in a database. Both products come with full source code for all supported
development environments (Windows, Macintosh and Unix).  NeoAccess is
priced at $749 per developer for full surce code for all supported
environments, and there are no licensing fees.  Support options are
available.

NeoAccess Introductory Toolkit is available without charge.  The
Toolkit consists of a 200+ page technical overview on the product plus
several sample applications with source code. This is everything you
need to determine what NeoAccess is and how you might use it in your
development.  The Macintosh, Windows and Unix versions of the
documentation can be downloaded from the NeoLogic home pages or FTP
site, or a diskette can be supplied upon request.

NeoAccess Version 4.0, released in October 1995, features full support
for Microsoft Visual C++ 4.0 IDE and the MFC 4.0 application framework.
The client/server database engine, NeoShare 1.1, was released in December
1995, and includes support for additional application frameworks.

NeoLogic Systems
1450 Fourth Street, Suite 12
Berkeley, CA 94710
U.S.A.

Voice: [phone]
Fax:   [phone]

Email:      [e-mail]
Compuserve: 71762,214
AOL:        NeoLogic
Apple Link: NeoLogic
Web:        http://www.neologic.com/~neologic/
Ftp:        ftp.neologic.com       /users/neologic

NeoLogic News:
To subscribe, send email to:  [e-mail]
with the following line:      SUB NeoAccess-Forum <Your Name>

NeoLogic Systems has representatives in Germany, Switzerland, UK,
Belgium, France, and Japan.


> OBST+

Xcc Software Technology Transfer offer OBST+, a full-featured, language
independant OODBMS with a C++-Interface and a Tcl/Tk binding. It's multiuser,
supports schema evolution, check-in/check-out, full access to the Meta-DB and
is available on several Unix-Platforms, and a Win NT port is underway.
A GNU-version is available. (archie search: OBST3-4.3.tar.gz)

Xcc Software Technology Transfer
Durlacher Allee 53
D-76131 Karlsruhe
Germany

Voice: 49-721-96179-0
Fax:   [phone]

email: [e-mail]

Web: http://www.xcc-ka.de/OBST/OBST.html
     http://www.fzi.de/divisions/dbs/projects/OBST.html

Ftp: ftp://ftp.fzi.de/pub/OBST/current
     ftp://ftp.xcc-ka.de/pub/OBST


> O2 (O2 Technology)

O2 Technology, Inc.

The O2 System is a fully modular object database, well adapted for
developing large-scale client/server applications. The O2 system conforms
to the ODMG 93 standard. O2 is an open system, which ensures its
compatibility with a corporate computing environment.

O2 integrates a powerful engine with a graphic programming environment, a
complete set of development tools and programming languages. The modules
can be integrated with existing relational database engines, GUI tools,
the World Wide Web, programming languages and CASE and methodology tools.

With O2, you can develop and run applications in areas where traditional
tools and systems cannot handle information efficiently (e.g.  management
of technical information, geographical information systems, CAD/CAM and
network management).

For more information on O2, consult the following REFERENCES:

Francois Bancilhon, Claude Delobel, Paris
Kanellakis.  "Building an Object-Oriented Database
System: The Story of O2".  Morgan Kaufmann Series
in Data Management Systems, San Mateo, Calif., 1992.

F. Bancilhon, G. Barbette, V. Benzaken, C. Delobel,
S. Gamerman, C. Lecluse, P. Pfeffer, P. Richard,
and F. Velez.  "The Design and Implementation of
O2, and Object-Oriented Database System".
Advances in Object-Oriented Database Systems,
Springer Verlag. (Lecture Notes in Computer Science
series, Number 334.)

C. Lecluse, P. Richard, and F. Velez. "O2, an
Object-Oriented Data Model".  Proceedings of
SIGMOD88.  Also appears in Zdonik and Maier,
"Readings in Object-Oriented Database Systems",
Morgan Kaufmann, 1990.

2 Technology, Inc.
3600 West Bayshore Road, Suite 106
Palo Alto, Ca 94303
U.S.A.

Voice: [phone]
Fax:   [phone]
Email: [e-mail]
Web:   http://www.o2tech.com


O2 Technology, Inc.
7 rue du Parc de Clagny
78035 Versailles Cedex
France

Voice: 33-1-30-84-77-77
Fax:   [phone]
Email: [e-mail]


O2 Technology
North Heath Lane
Horsham
West Sussex RH12 5UX
United Kingdom

Contact:  Dr. Sharon Cooper

Voice: (44) 403 211 020
Fax:   [phone]
[e-mail]

Web: http://www.o2tech.fr/  Note: this Web server is built on top
                                  of O2Web, the O2 WWW gateway, and
                                  uses the O2 ODBMS for a backend.


> Objectivity/DB (Objectivity)

Introduction:

Objectivity/DB has a fully distributed client/server architecture that
transparently manages objects distributed across heterogeneous environments and
multiple databases.  It provides an application interface that uses transparent
indirection to ensure integrity and provides a single logical view of all
information, with all operations working transparently on any database on the
network, with scalable performance as users and objects increase.  A
higher-level Object Definition Language (ODL) is available as well as a C
functional interface, integrated C++ interface, and SQL++.


Objectivity/DB

Objectivity/DB [Reference:  Technical Overview, Objectivity, 1993], a product
of Objectivity, Inc. of Menlo Park, CA, provides an integrated C++ programming
interface with an emphasis on the DBMS engine for robustness and scalability
from workgroups to enterprise-wide production applications.  In production use
today with more than 50,000 end users licensed, it supports a fully
distributed, rather than central-server, architecture, with all operations
working transparently over a mixture of multiple databases, schemas, users, and
computers, and over heterogeneous hardware, operating systems, and networks.
The language interface includes a C++ class library interface, soon to be ODMG;
a C function library; and SQL++, supporting query predicates with either SQL or
C++ syntax, interactively or programmatically.  Over forty administrative and
GUI tools provide both an interactive and programmatic interface, and a
messaging backplane allows third party tools integration at four different
levels, with a list of partners at all levels.

One of the key architectural concepts of Objectivity/DB is an object reference
mechanism that ensures data integrity.  Unlike traditional ODBMSs that use
direct pointers, which become invalid after commit and hence lead to crashes
and corrupt databases, Objectivity/DB uses an indirection to guarantee safe
reference.  Transparent to the user, this indirection requires an extra test
and pointer dereference, or a couple of cycles, which is not measurable in most
applications.  However, it ensures integrity of all references, even across
transaction boundaries, resulting in production quality robustness.  Also, it
provides object level granularity for the object manager, allowing it to move,
cluster, and swap objects as necessary, one of the keys required for
scalability in objects and users.  Finally, it allows object-level granularity
for current features, such as heterogeneity and versioning, and future
extensions, such as object-level security.

A higher-level Object Definition Language (ODL) is provided that allows
declaration of modeling concepts such as bi-directional associations, behavior
of associations between objects as they version (move, copy drop), and
propagation of methods across associations.  These then result in automatically
generated methods and declarations for both C++ and C.  The standard C++ API
allows application programmers to work with any standard compilers and
debuggers, with no extra pre-processors, providing ODBMS capabilities via
overloading C++ operators (new, ->, etc.), and declarations via provided
classes (for references, etc.).

Workgroup through enterprise-wide and cross-enterprise computing is supported
via a distributed client/server architecture that provides a single logical
view over multiple databases on heterogeneous machines.  The user sees a
logical view of objects connected to objects and need not worry that one object
is in a database on a Sun workstation, while another may be in a database under
Windows or VMS.  All operations work transparently across this environment,
including atomic transactions with two-phase commit, propagating methods, and
versioning.  Objects may be moved between databases and platforms without
affecting working applications or requiring changes to the applications.
Multiple schemas may be created, without affecting other users or databases,
and may be used simultaneously with shared schemas, allowing local groups to
define their own models but still connect to other groups.  Databases may be
detached from this shared environment (federated database) and used on portable
devices, reconnected or moved to different (compatible) environment, or
distributed as parts or image libraries.  Gateways to RDBMSs are provided via
third-party integration with Persistence Software, and more generally to any
foreign data store, as long as the user installs the appropriate access
methods, extending the single-logical-view to include read/write access to
arbitrary foreign data stores.  Together, these allow delegation of
responsibilities to the appropriate users, integration with existing systems,
and gradual migration toward full enterprise-wide sharing.

The on-demand object manager directly and automatically manages object access
and buffering, rather than relying on system facilities such as virtual memory
or user manual get/put calls.  Mechanisms used include multiple buffer pools
locally and remotely, b-trees, hashing, scoped names, keys, and iterators, with
distributed catalogues for schemas and databases.  A direct connection is
established between the user and the objects used, so that users do not
conflict unless and until they are competing for the same objects, thus
avoiding the traditional central-server bottleneck.  Short transactions are
based on traditional (transient) locks, owned by the process, and group
together an arbitrary set of operations.  Long transactions are based on
persistent locks, owned by the user, and provide the same arbitrary grouping.
Default concurrency is two-phase locking and serialization, but extensions
available include MROW, or multiple-readers concurrent with one-writer, and
allow users to lock with or without wait or with timed waits, to implement more
sophisticated mechanisms.

Objects may be modeled using C++ structures augmented by classes provided such
as strings, dictionaries, and relationship management, as well as some
particular domain libraries.  A simple object is a C++ class (or C structure)
with associated access methods.  A complex object may include multiple varrays,
each being a dynamically varying sized array of arbitrary structure.  A
composite object is any network of related objects that acts as a single
object, both structurally and behaviorally, via propagation of behaviors to
component objects.  Any number of composite objects may be contained in
composite objects, and a single object may participate in any number of
composites.  The relationship mechanism supports uni- and bi-directional
relationships, one-to-one, one-to-many, and many-to-many.  Versioning is
supported at object granularity, may be turned on or off at any time for each
object, may be restricted to linear or allow branching with multiple writers.
References to versioned objects may be to a specific version or to the default
version, which may be separately specified by a method and may allow multiple
defaults.  Schema and object evolution are supported via versioning of the
type-defining objects.  Each time a type definition is changed, its defining
object is versioned, allowing arbitrary changes.  Objects may then be instances
of the old or new type version.  Object evolution or upgrading to the new type
version is supported  by the user writing conversion methods which are
installed and invoked by the system.

ANSI SQL query is supported in the SQL++ product.  Predicate syntax may be
either C++ or SQL.  The ODBC and SQL Access Group (SAG) protocols are
supported.  Queries may be invoked programatically or interactively, with ad
hoc support.  Access to object features is available via methods and traversal
of relationships.

Over forty administrative and developer tools are provided, each with both an
interactive and programmatic interface.  These include GUI object and type
browsers, query browsers, report generator, tools to examine and force short
and long locks, to move objects and databases, etc.  On-line incremental backup
provides a consistent network-wide snapshot, including referential integrity
across all databases, and runs incremental and full database backups with no
need to acquiesce the databases and no interference with active applications.
All tools are built around a messaging backplane, which supports four levels of
integration with user and third-party tools.  Integrated products include HP
SoftBench (full operational level), CenterLine's ObjectCenter (tool level),
Persistence RDBMS gateway, PTech and ProtoSoft Design and Analysis (language
level), and XVT and UIM/X (compatibility level).