Search the FAQ Archives

3 - A - B - C - D - E - F - G - H - I - J - K - L - M
N - O - P - Q - R - S - T - U - V - W - X - Y - Z - Internet FAQ Archives

Comp.Object FAQ Version 1.0.9 (04-02) Part 7/13

( Part1 - Part2 - Part3 - Part4 - Part5 - Part6 - Part7 - Part8 - Part9 - Part10 - Part11 - Part12 - Part13 )
[ Usenet FAQs | Web FAQs | Documents | RFC Index | Neighborhoods ]
Archive-name: object-faq/part7
Last-Modified: 04/02/96
Version: 1.0.9

See reader questions & answers on this topic! - Help others by sharing your knowledge
Objectivity/DB is resold by Digital Equipment Corporation as DEC Object/DB,
providing a multi-billion-dollar second source vendor.  Over 50,000 end users
are licensed in production use, with applications including real-time
telecommunications, aerospace, defense, case, CAD/CAM, CIM, manufacturing, oil
& gas, process control, transportation, multi-media, case, document management,
financial analysis, and corporate information management.  Platform support
includes all Sun, all DEC (including VMS, alpha, OSF-1), HP/9000 series (both
68xxx and PA-RISC), IBM RS/6000, NCR 3300, SGI, Windows 3.1, and Windows NT.

On Schema Evolution (from original survey):
In the just-released Version 2.0 (shipping Oct 92), schema evolution
is supported via dynamic versioning of type-defining objects [ie.
class versions -- SMC], and via a step-by-step approach that allows
conversion of instance data via user-provided conversion methods.
Also, a full dynamic type manager interface is available for doing
fancier things.

Objectivity, Inc.
301B East Evelyn Avenue
Mountain View, CA  94041-1530

Voice:     (415) 254-7100
Fax:       (415) 254-7171
Toll Free: 1-800-676-6259   1-800-SOS-OBJY


Objectivity maintains regional offices in Los Angeles, CA; Burlington,
MA; Iselin, New Jersey.

Beijerscheweg 28a
2821 NG Stolwijk
The Netherlands

Voice: +31 1820 50506
Fax:   +31 1820 12362
Rick ter Horst -

Objectivity - Europe
Socratesstraat 22
The Netherlands

Voice: +31 85 235 907
Fax:   +31 85 235 541
Henk Nijenhuis -

Additional representatives in Ireland, France, Germany Sweden, United
Kingdom, Israel, Italy, Portugal, Switzerland, Taiwan, Japna, Hong Kong

> ObjectStore

Product Description	

ObjectStore[TM] is a high performance ODBMS designed for ease of use in
development of sophisticated applications using object-oriented
development techniques.  It offers a tightly-integrated language
interface to a complete set of traditional DBMS features including
persistence, transaction management (concurrency control and
recovery), distributed access, associative queries over large amounts
of data, and database administration utilities.  ObjectStore's data
management facilities combined with popular development tools create a
high productivity development environment for implementing
object-oriented applications.

Key Features:

   - Transparent interface designed for popular C and C++ programming

   - Concurrent access to large amounts of persistent data. 

   - Distribution of objects over networks using a variety of popular
     network protocols.

   - Access to persistent data at the same speed as transient data.

   - Extensible data modeling capabilities for applications requiring
     complex data structures.

   - Easy migration path for existing C and C++ applications.

   - Class libraries for version and configuration management.

   - Class libraries for managing collections of objects.

   - A fully distributed (multi-server/multi-database) ad hoc query

   - An interactive Browser to inspect objects and object

   - Interoperable with ObjectStore servers running on other operating
     systems and hardware environments.

   - Complete schema evolution for an application's metadata and
     existing object instances.

   - Full online backup for continuous processing environments.

   - Meta object protocol with programmatic access to schema

   - Dynamic Type creation for extending existing class definitions
     during program execution.

System View

ObjectStore supports cooperative access through its flexible
client/server software architecture, which allows users to make the
take advantage of the computational power that exists on the desktop.
ObjectStore's client/server implementation allows one server to
support many client workstations, each workstation to simultaneously
access multiple databases on many servers, and a server to be resident
on the same machine as a client.  ObjectStore's distributed
architecture supports several network environments for
interoperability among popular workstations and PC's and includes
support for TCP/IP, Novell IPX/SPX, other popular network protocols.

Application Interface

Access to ObjectStore is provided through a library based application
interface compatible with popular C and C++ compilers and programming
environments.  The ObjectStore application interface provides support
for C++ compilers -- such as those from workstation suppliers -- and
development environments from independent software vendors such as
Visual C++ from Microsoft, ObjectCenter from CenterLine Software, Inc.
and Energize from Lucid, Inc.  The application interface provides
powerful high-level function calls which enable the programmer to
create multi-user application which share large amounts of data.
These functions include:

   - Relationship Management
   - Version Management
   - Collection Management
   - Storage Management
   - Associative Queries
   - Object Iteration
   - Transaction Management 
   - Index Management
   - Clustering

Applications developed using ObjectStore library calls are
source-level compatible with ObjectStore applications developed for
other operating systems on other hardware platforms.


ObjectStore is available on the following major platforms:
Unix Workstation Platforms

   - DEC MIPS Ultrix 
   - HP 700 Series HP-UX
   - HP 800 Series HP-UX 
   - IBM RS/6000 AIX
   - NCR 3000 
   - Olivetti LSX-50xx SVR4
   - Silicon Graphics IRIX 5.x
   - SunSoft Intel Solaris 2
   - SunSoft SPARC Solaris 1 SunOS 4
   - SunSoft SPARC Solaris 2 SunOS 5
   - Univel UnixWare

PC Platforms

   - Windows 3.1 (Win32s)
   - Windows NT (Intel)
   - OS/2 Release 2.0 and 2.1
   - Novell Netware Release 3.1 and 4.0 (server only)

The Company

Object Design, Inc.
25 Mall Road
Burlington, MA  01803

Voice: 1-800-962-9620
       (617) 674-5179
       (617) 674-5000
Fax:   (617) 674-5010


Offices in Asia Pacific, Europe and throughout the U.S..  Full contact
information available through their web page.

The German user group (OS_UG) has a web site:

> ONTOS [formerly VBase] (Now ONTOS, Inc. formerly Ontologic)

Entry on schema evolution only:

*Ontos provides schema evolution. It allows any class to be modified.
*The major drawback is that data does not migrate ie., instances are
*not modified to adopt to the new class definition. So schema changes
*can be done only on classes that do not contain instances and do not
*have sub classes that contain instances.

*As a system for experiments, we are currently using ONTOS from
*Ontologic Inc.  Unfortunately, there is no transparent concept of
*schema evolution for populated database. Thus, we still investigate
*how it works.

ONTOS, Inc. provides object-oriented products and services that enable
users to integrate, distribute, and manage information across the

Product Overview:  The ONTOS Virtual Information Architecture (ONTOS VIA)
is a strategy for integrating an organization's disparate information
resources.  It includes a set of products for developing and deploying
distributed, network-based applications and for accessing information
stored in a variety of formats.  ONTOS VIA allows organizations to take
advantage of new technologies while preserving existing technology

The products that make up ONTOS VIA include ONTOS DB, a fully distributed
Component Object Database and ONTOS Object Integration Server (ONTOS
OIS), which provides object access to relational and mainframe databases.
ONTOS products are available on UNIX and Microsoft operating environments.

900 Chelmsford St.
Lowell, MA  01851

Voice: (508) 323-8000
Fax:   (503) 323-8101

> Odapter/OpenODB (Hewlett-Packard)

Odapter is HP's new object/relational adapter which
enables object-oriented developers to share a common
object model stored in the ORACLE7 relational database
management system (RDBMS).  Odapter is also available with
HP's ALLBASE/SQL RDBMS.  The combination of Odapter
and ALLBASE/SQL is called OpenODB.

Technical Data 
Object/Relational Adapter 
A Productivity Tool for Scalable Object-Oriented 
Odapter is a tool for developers writing scalable 
object-oriented applications requiring the 
integration of new objects and legacy information. 
Odapter is valuable because it: 
* accelerates application development 
* reduces the cost of keeping applications current 
* enables applications to scale 
Odapter delivers the productivity of object 
technology while adhering to your data management 
Consider Odapter if you need to be able to do one 
or more of the following: 
* develop object-oriented applications and 
store objects in a relational database 
* easily access legacy data and existing 
applications from your new system 
* support a large number of end-users who will 
be simultaneously accessing information 
* store large amounts of  complex information 
The following are examples of applications well- 
suited for Odapter: 
* a customer billing application written in 
Smalltalk combining data stored in DB2 with new 
objects. (Telecommunications) 
* a network management application written in C 
using Odapter as the object manager, able to scale 
to millions of objects (Manufacturing) 
* a complex Oil and Gas industry standard model 
automatically generated from an Express analysis 
and design tool. 
(Oil & Gas) 
* a medical application using Odapter to 
combine heterogeneous components of patient 
records. (Healthcare) 
Odapter provides authorized access to sharable 
objects, including existing data and business 
processes. By bringing object-oriented capabilities 
to heterogeneous systems environments, Odapter 
delivers increased functionality while leveraging 
the stability of existing RDBMSs and legacy 
Odapter Object Model 
The Odapter object model is based on three key 
concepts - objects, types and functions. 
* Objects are a combination of data and 
behavior (functions). Figure 2 is an example of an 
* Types are dynamic templates allowing you to 
group together similar components or objects. 
* Functions define the attributes, 
relationships and behavior of objects. Odapter 
supports four types of user-defined functions: 
Stored functions define attributes and 
relationships that are stored in the database. In 
Figure 2, flightno is a stored function. The 
functions aircraft and crew are also stored 
functions with user-defined results. 
SQL-based functions allow you to access existing 
relational tables with Odapter's object-oriented 
model. In Figure 2, citypair is an SQL-based 
function accessing values from an existing 
relational table. 
OSQL-based functions define attributes and 
relationships that are derived or calculated with 
OSQL statements. In Figure 2, delay and depart are 
OSQL-based functions. Delay calculates changes in 
arrival and departure times based upon events that 
disrupt the schedule; depart handles the update of 
functions related to departure and transitions the 
flight from OnGround to InAir. 
External functions are a reference to code or data 
stored outside of Odapter. In Figure 2, cancel is 
an external function that executes code outside of 
Odapter to free up resources no longer assigned to 
the flight. 
Odapter Language 
The Odapter language can be combined with functions 
implemented in C++, Smalltalk or C. You create and 
manipulate objects, types and functions using 
Odapter's object-oriented structured query language 
(OSQL). OSQL is a functional language that is a 
semantic superset of SQL, the structured query 
language for relational databases. OSQL is a 
computationally complete language with statements 
allowing you to define and manipulate information 
in your Odapter enhanced relational database, 
specify authorization for individuals or groups, 
define transactions, embed program logic within 
functions, and administer the database. 
OSQL includes programming flow statements, such as 
IF/THEN/ELSE, FOR and WHILE. This procedural 
language allows Odapter functions to model complex 
behavior, simplifying your application code. By 
decoupling behavior from the applications, multiple 
applications can share information with benefits 
such as consistency, security and integrity. See 
Table 5 for a list of all OSQL statements. 
Odapter Object Storage 
Odapter objects are stored in the developer's 
choice of relational databases. Odapter interfaces 
to the underlying RDBMS through an SQL command 
interface. Currently, developers can choose to 
store their objects in ORACLE7 or HP ALLBASE/SQL. 
The choice of RDBMS is made when a particular 
database is created. The users are only limited by 
the number of Odapter concurrent user licenses 
purchased. This flexibility allows database 
administrators to continue using their existing 
administration procedures and keeps the group from 
having to choose yet another database management 
During the initial development of an application, 
developers can make rapid progress without 
knowledge of the underlying relational database. 
Optimization of the objects and how they are stored 
in the underlying relational database is best 
done during the deployment phase. 
Odapter Development Environments 
Odapter developers have a choice of development 
environments. Whether Smalltalk, C++ or more 
traditional C and C-linkable languages are used, 
Odapter enables object storage in a scalable and 
robust relational database. In fact, objects can be 
shared between different applications, allowing 
different projects to employ the best tools for the 
Odapter and Smalltalk 
Odapter provides Smalltalk developers with 
transparent access to information stored in the 
underlying relational database. 
Odapter's Smalltalk Class Builder utility 
automatically generates ParcPlace Smalltalk 
compatible classes and methods based upon an 
Odapter object model. The developer can select 
specific Odapter types and functions, resulting in 
a corresponding set of Smalltalk classes and 
methods. Once the Smalltalk schema is generated, 
the Smalltalk developer can transparently access 
the underlying relational database, as shown in 
Figure 3. 
   allFlightObject:=Flight allObjects. 
   AllFlightObjects do: [:aFlight| 
      Transcript show :aFlight flightno value; cr]. 
Figure 3 
Figure 3 shows how to access the flight objects 
shown in Figure 2 through Smalltalk. This example 
retrieves all flight object identifiers and prints 
the flight# for each one of the flight objects. 
All Smalltalk classes and methods which result in 
the access of Odapter structures are italicized. 
Flight is a Smalltalk class that corresponds to the 
Odapter type Flight. The Smalltalk methods 
allObjects and flightno map to Odapter calls that 
access data from the relational database storage 
Odapter and C++ 
For C++ developers, once the corresponding C++ 
model is created, Odapter provides the abilility to 
manage C++ objects stored in the underlying 
relational database, as shown in Figure 4. 
void printFlight() 
   int i; 
   ODBType Flight ("Flight"); 
   ODBBag allFlights=Flight.allObjects(); 
   ODBFunc flightno("flighno"); 
Figure 4 
Figure 4 shows a C++ version of the Smalltalk 
example in Figure 3. That is, Figure 4 shows how to 
access all the flight objects shown in Figure 2 and 
prints the flight number associated with each 
flight object. 
The Odapter C++ library includes a set of classes 
(e.g. ODBType, ODBClass, ODBFunc, ODBBag) and 
corresponding member functions (e.g. allObjects). 
User-defined classes (Flight) and member functions 
(flightno) are also shown. In Figure 4, all Odapter 
calls are in italics. 
Odapter and C-linkable Languages 
For traditional developers using C, or any 
languages linkable with C, the object-oriented 
features are provided by Odapter. Odapter objects 
are manipulated by embedding OSQL statements in the 
C program, similar to the db.execosql call shown in 
Figure 4. In addition, the C interface requires the 
conversion of data types from Odapter to C. 
By embedding Odapter calls in a C program, the C 
language becomes object-oriented. 
Features and Benefits 
Accelerates Application Development 
Odapter accelerates application development by 
integrating with familiar development environments 
and by providing a robust object-oriented model. 
Odapter's choice of development environments 
includes those which support the Smalltalk, C++ and 
C languages. 
Odapter's robust object model enables the 
integration of legacy data and business processes 
in the context of one sharable business object 
model, shielding the developer from the data 
storage complexity. 
The following Odapter features accelerate 
application development: 
Automatic mapping of objects to relational 
The application developer is shielded from the task 
of converting complex object models to two 
dimensional relational tables. 
Smalltalk Class Builder 
Once an OSQL schema is created, whether using 
available analysis and design tools or manually, 
Odapter's Smalltalk Class Builder can generate 
corresponding Smalltalk classes and methods. The 
developer can select the relevent part of the 
Odapter schema to generate. As the Odapter object 
model changes, developers can also incrementally 
update the Smalltalk classes. 
Object Identity 
Each object manipulated by Odapter has a unique, 
system-provided handle called an object identifier 
(OID). OIDs eliminate the need for creating unique 
keys to identify stored information. Additionally, 
OIDs reduce duplication of information when several 
attributes would be needed to uniquely identify 
information in the database. OIDs are also a 
powerful way to tune data access and performance. 
Odapter objects can use functions defined on parent 
types in the type hierarchy. For example, as shown 
in Figure 5, a subtype of Employee called Pilot 
could inherit functions from Employee like hire and 
name, while defining unique functions like 
hoursflown and status. 
Multiple Inheritance 
Functions defined on a type can be inherited by one 
or more subtypes. In Figure 5, functions accessible 
by the type ManagingPilot are inherited from its 
parents, namely all functions defined on Employee, 
Pilot and Manager. By inheriting rather than 
redefining functions, you can easily add 
functionality to your application. 
If you already know SQL, you can quickly be 
productive using Odapter's OSQL. Both query 
languages are set-based, that is they retrieve sets 
of information based upon queries. Thus, OSQL does 
not require users to navigate through the database 
chasing pointers or object references. 
Odapter protects end-user applications from changes 
to the internal definition of objects. Since 
Odapter only allows access to data through 
functions with well defined arguments and results, 
your applications are protected from changes to the 
function body and you have control over how 
information is used. 
Aggregate Types 
Aggregates are used to represent collections, such 
as crew members (maybe several pilots, flight 
attendants and a mechanic) for a particular flight, 
or the employees reporting to a particular manager. 
Aggregates are not required to have a predetermined 
size. Odapter manages the memory associated with 
aggregates, relieving your application of this 
User-defined Data Types 
You can construct user-defined data types in 
Odapter, such as a type called Flight, Employee or 
Aircraft, as shown in Figure 6. Functions defined 
on these types can manipulate data stored within 
the current object, within other related objects or 
outside of Odapter. User-defined types maximize 
flexibility and lead to more manageable, clearer 
Complex Objects 
With Odapter you can construct complex objects from 
simpler objects. For example, Figure 6 shows the 
relationships between the types Flight, Aircraft 
and Employee.  Complex objects relieve applications 
from managing such relationships. 
Reduces the Cost of Keeping Applications Current 
Odapter supports a server-centric business model 
which means the business logic and associated data 
is sharable by multiple applications. By separating 
out business objects (data and processes), from the 
application development environment, your company's 
business can be modified without impacting the 
applications. These changes can be immediately 
leveraged by the calling applications without 
The following features make applications easier to 
keep current: 
External Functions 
Using external functions, you can access 
distributed data and code stored outside of the 
relational database used by Odapter for storage, 
regardless of location or data format. Examples of 
external data sources include IMS, DB2 as well as 
custom databases and flat files. Odapter acts as an 
integrator so your application can manipulate 
information as recognizable business objects. This 
not only allows transparent migration of data over 
time, it accelerates developer productivity by 
hiding the complexity of a diverse data storage 
Overloaded Functions 
Multiple functions can have the same name with 
different implementations. An application calls a 
function (e.g. salary) and Odapter determines at 
run-time which code (salary for Manager or salary 
for Pilot) to execute, based upon the type of the 
object against which the function is invoked. The 
application is simplified since the conditional 
logic for determining which function to execute is 
now in Odapter. 
Dynamic Schema Modification 
Odapter object models can be modified while the 
database is running. Developers can add new 
functions and types, as well as change the 
implementation of functions. This capability is 
particularly valuable to applications with high 
availability requirements. 
Dynamic Typing 
You can change the type of an object without 
destroying and recreating the object. An object can 
also belong to more than one type. As shown in 
Figure 7, once a Flight leaves the ground, it would 
change state from being an OnGround to an InAir 
Flight. OnGround functions such as maintenancecrew 
and availableseats would no longer be needed. An 
InAir object would need certain functions like 
bestroute and delay to calculate the most time 
efficient route and to calculate a projected delay 
based current weather conditions. Dynamic Typing 
allows you to represent an object in Odapter which 
transforms itself over time and, therefore, changes 
capabilities and attributes. 
Late Binding 
Odapter supports functions that are resolved at 
runtime. Late binding allows you more flexibility 
in application development and gives you the full 
power of overloaded functions as described earlier. 
On the other hand, Odapter will precompile or do 
early binding to improve performance. However, when 
types and functions changes at runtime, impacting a 
particular function, late binding occurs and the 
application automatically takes advantage of the 
new implementation of the function when it is 
Referential Integrity 
Since Odapter manages the relationships between 
objects, it can manage referential integrity on 
your behalf. That is, if an object referenced by 
other objects is deleted, the system removes all 
dependencies.  Your application code is simplified 
since Odapter is able to keep the logical business 
model intact automatically. 
Odapter allows you to manage large, unformatted 
data in binary format and treat that data as an 
attribute of an object. For example, you may want 
to create a function called diagram to show the 
sections and seating for an Aircraft object. 
Multimedia information can include graphics, images 
and voice. You can also define functions in Odapter 
to manipulate this multimedia information. For 
example, you can create a function called showexits 
that adds information to the diagram. Thus, various 
applications can share these complex functions. 
Import Facility 
The Odapter Import facility allows developers to 
update existing Odapter functions with data from 
external files such as spreadsheets or other 
databases. This is an object-oriented version of 
the relational "bulk load" functionality. 
Enables Applications to Scale 
Odapter makes applications more scalable by storing 
objects in a choice of RDBMSs, like ORACLE7. As a 
result, applications can access large volumes of 
data, be used by a large numbers of users, and 
perform on-line backup. In addition, Odapter 
protects against unauthorized access from users in 
a distributed environment. 
Odapter, with the help of the underlying relational 
storage manager, ensures the integrity and security 
of your data while maximizing the availability of 
that data for end users. 
The following features enable applications to 
Indexes are automatically generated when you create 
types and functions in Odapter. You can also define 
your own indexes using B-tree and hashing 
algorithms. Indexes make end user access to 
information faster. 
Related functions and objects which have the same 
value for a function can be stored close to each 
other. This ability to influence how objects are 
stored allows you to tune the performance of the 
database based on how the information will be 
accessed by applications. 
Transaction Management 
Odapter ensures the logical and physical integrity 
of your database by giving you complete control 
over the unit of work to be performed within a 
single transaction. With this control, you can save 
or rollback a transaction (throw away temporary 
work) at your discretion. Savepoints are also 
supported so that you can rollback parts of a 
Multi-user Concurrency Control 
Odapter is designed to support hundreds of users 
accessing the same information while guaranteeing 
the integrity of that information. 
You can control access to an Odapter enhanced 
database at the database and function levels based 
on individuals or groups of users. For example, 
authorization statements can provide read access to 
a large group of users while limiting write or 
delete access. 
High Availability 
Because Odapter actually stores objects in an 
RDBMS, Odapter can leverage RDBMS features to 
maximize the availability of your information by 
* on-line backup of the database, to backup the 
database while it is being accessed 
* dual logging, to ensure the integrity of your 
log file 
* switch log, to automatically switch to a 
second log file if the original log file becomes 
* dynamic file expansion, to expand the size of 
your database as it becomes full 
Odapter will also take advantage of other available 
features of the underlying relational database 
management system such as replication or "warm 
Odapter uses the robust logging and recovery 
facilities of the RDBMS. In case of a failure, you 
can rollback work or perform rollforward recovery 
to a particular time, using the log file to 
recreate saved work. 
Odapter  Software Components 
Odapter uses a client/server architecture, enabling 
you to efficiently utilize your computing power. 
Clients use the object application call interface 
(OACI) to communicate with the server over the 
network. The clients and server components can also 
reside on the same machine. 
Odapter is bundled with the following client and 
server components, as shown in Figure 8: 
Client Components 
* Interactive Object-Oriented SQL (IOSQL) 
This interface allows you to interactively enter 
all Object-oriented SQL (OSQL) statements, 
facilitating rapid prototyping and testing. IOSQL 
provides query, administration and editing 
* Graphical Browser (GOSQL) 
The Graphical Browser is a tool that allows you to 
graphically explore your database schema and 
contents, and execute any OSQL statement. This tool 
is designed to assist application developers by 
making it easier to view and manipulate your object 
model stored in Odapter. 
* Windows OSQL (WINOSQL) 
This PC-based interactive interface to OSQL allows 
you to interactively enter all OSQL statements. 
* Object Application Call Interfaces (OACI) 
Odapter provides client interface libraries for the 
Smalltalk and C++ object-oriented programming 
languages, allowing these languages to be tightly 
coupled with Odapter. 
You can also write Odapter applications using any 
programming language that can be linked with C 
(such as Ada, COBOL, FORTRAN and Pascal). The 
programmatic interface is similar to a "Dynamic 
SQL" interface, and passes strings representing 
OSQL statements to the Odapter server. No 
preprocessors are required. 
Server Components 
* Odapter Object Manager 
The Object Manager executes OSQL calls made by the 
Odapter clients. The Object Manager processes 
requests, and accesses data and code stored in the 
Odapter enhanced relational data storage manager or 
passes the request to a subsystem outside of 
Odapter using Odapter External Functions. 
* External Functions 
External functions allow you to access data and 
code stored outside of Odapter, regardless of data 
format or location. External functions can 
automatically link to specific data sources using 
the Odapter EDA-Objects class library and the 
EDA/SQL product from Information Builder's, Inc. 
(IBI). External functions can also be implemented 
by you as subroutines written in general-purpose 
programming languages and compiled outside of 
Odapter. External functions can be called by any 
OSQL statement, allowing you to manipulate this 
remote data and application code like any other 
Odapter object. For example, Figure 9 shows how 
Odapter integrates diverse heterogeneous 
information in an Oil and Gas environment. 
* EDA-Objects 
HP and IBI have jointly developed an external 
function library called EDA-Objects. Coupled with 
IBI's EDA/SQL product, EDA-Objects provides 
connections to over 50 commonly used databases on 
35 different platforms. The external function 
library to connect to EDA/SQL is shipped with 
Odapter; however, you must purchase other EDA/SQL 
components from IBI directly to use the product. 
EDA-Objects is one way to integrate external data 
from multiple servers into a single business model 
managed by Odapter. This is done without physically 
moving the data or changing the applications which 
are dependent on the data in its current form. 
Additional Products 
* Development Environments and Tools 
Odapter allows you to use your favorite development 
environments for application development. Some 
tools are more tightly coupled with Odapter than 
others. HP has recruited tools partners to address 
all aspects of application development including 
application design and analysis, data model 
manipulation, fourth generation language 
application development, report writing and legacy 
data access. 
* Relational Database 
Odapter uses a relational database as its storage 
manager for the storage of Odapter objects. The 
relational database performs physical file 
management and database functions such as multi- 
user concurrency, transaction management, and 
recovery. The relational database allows you to 
perform on-line backup and recovery, manage 
physical distribution of files, maximize 
availability and change database parameters. 
COMPASS is a consulting product which includes the 
Hewlett-Packard implementation of the 
Petrotechnical Open Software Corporation (POSC) 
Software Integration Platform (SIP) specification. 
The SIP specification defines a data model and an 
interface which allow users and applications to 
access exploration and production data, independent 
of the database engine technology. 
The COMPASS package is an add-on to Odapter and 
* COMPASS specific consulting/training (1 day) 
* POSC-based DAE interface library and documentation 
* Interactive user interface called ixpres 
* Archived copy of a pre-loaded Odapter 
enhanced database with sample reference data 
* Scripts for building a POSC-based Odapter 
enhanced database 
* Contributed software library (data loaders, 
demonstration programs) 
COMPASS gives developers a 'jump start' on building 
applications focused on petroleum exploration and 
production. Other industries will find COMPASS an 
inexpensive and useful approach for building 
geographic information systems (GIS) and other 
applications which can re-use of the cartography 
(mapmaking) and geometric objects defined in the 
POSC is a not-for profit organization created to 
lower the costs associated with accessing and 
integrating exploration and production data for the 
oil and gas industry. 
System Environment 
Hardware       Operating    Memory      Disk Space 
platform       System       (minimum)   (minimum)* 
HP 9000 S700   HP-UX 8.07   32MB        10MB + 
S800           or later                 necessary 
                                        swap space 
Sun            Solaris 1.0  32MB        10MB + 
               (SunOS 4.3);             necessary 
               Solaris 2.0              swap space 
               (SunOS 5.2) 
IBM RS/6000    AIX 3.2.5    32MB        10MB + 
                                        swap space 
X Terminal                  6MB         none 
IBM PC         DOS 5.0,     4MB         1MB 
compatible     MS-Windows 
               3.1 or later 
Table 1:  Odapter Client Environments 
* Swap space needed will depend on the complexity 
of the application and the number of concurrent 
users. Swap space will significantly increase the 
necessary disc space. 
Hardware       Operating    Memory      Disk Space 
platform       System       (minimum)   (minimum)* 
HP 9000 S700   HP-UX 9.0    64MB        15MB + 
S800           or later                 necessary 
                                        swap space 
Table 2:  Odapter Server Environment 
* Additional memory may be required. Swap space 
will significantly increase the necessary disc 
space. The amount of memory and swap space depends 
on the complexity of the application and the number 
of concurrent users. 
Odapter Software Requirements 
To use Odapter, you will need one of the RDBMSs 
listed below, TCP/IP transport and ARPA Berkeley 
Services (for Unix systems), HP LAN Manager or 
Microsoft LAN Manager (for the PC client) software. 
To use the Odapter Graphical Browser, you will need 
X11 X-Window support. 
Table 3: Relational Databases 
            Version          Memory      Disk Space 
                             (minimum)   (minimum) 
ORACLE7     7.0.13 or later  refer to    refer to 
            with "procedural Oracle      Oracle 
            option" (PL/     manuals     manuals 
            SQL), Pro*C, 
            SQL*Plus & Oracle 
            common libraries and 
ALLBASE/SQL shipped with     64MB A/SQL  10MB 
            OpenODB          and Odapter 
* ALLBASE/SQL is included with the Odapter 
software. The combination of Odapter and 
ALLBASE/SQL is known as OpenODB. 
Ordering Information 
Software, training, consulting and support can be 
purchased separately, as well as in bundles. 
Pricing for the stand-alone software is based on 
the number of user processes accessing a single 
database server at the same time. Any number of 
user licenses can be ordered. You must also order 
the Odapter Media & Manuals product when ordering 
the Developer's Bundle or the Concurrent User 
License. HP standard support options are available 
for all Odapter license and media products. 
The OpenODB and Odapter products are sold together. 
OpenODB is the combination of Odapter and 
ALLBASE/SQL. You are only limited by the number of 
concurrent licenses purchased for Odapter. 
Product Number and Product Description 
B3767BB  Odapter/OpenODB Concurrent User License 
Software license only. Must order B3768BA to 
receive software and manuals. Must specify number 
of users. 
B3768BA  Odapter/OpenODB Media and Manuals  Must 
choose media option. Includes software and one set 
of manuals. Requires prior or concurrent purchase 
of software license. 
B2470BA  Odapter/OpenODB Developer's Bundle 
Includes 8 user software license, 5 days of on- 
your-site consulting, one year of on-line support 
and 2 passes to the Odapter/OpenODB Training Class. 
Must order B3768BA to receive software and manuals. 
B3179A  Odapter/OpenODB Evaluator's Bundle 
Includes a 40 user software license for 3 months, 
media, documentation, 3 months of on-line support, 
and 1 pass to the Odapter/OpenODB Training Class. 
B3184S  Odapter/OpenODB Training Class (5 days) 
B3185A  Odapter/OpenODB Reference Manuals  Includes 
the Odapter/OpenODB Reference Manual and the 
Odapter/OpenODB System Functions Manual. 
B3186A  Odapter/OpenODB Consulting  Customized 
consulting in any of the following areas: COMPASS, 
object-oriented analysis and design, schema design 
and review, authorization/security design and 
review, performance tuning, advanced usage, 
Odapter/OpenODB application development planning 
and review and implementation of access to legacy 
data sources. 
To order these products, please contact your local 
HP sales representative or one of the offices on 
the back page of this document. 
Table 5. Odapter Features 
Aggregates (BAG, LIST, SET, TUPLE) 
Complex Objects 
Dynamic Schema Modification 
Dynamic Typing 
External Functions 
Functions (Stored Code or Methods) 
Late Binding 
Multiple Inheritance 
Object Identity (OID) 
Overloaded Functions 
Type (Class) Hierarchy 
User-defined Data Types 
Versioning Primitives 
Graphical Browser (GOSQL) 
Interactive OSQL 
Object Application Call Interfaces (OACI): 
  C-linkable languages  (Ada, COBOL, FORTRAN, 
Smalltalk Class Builder 
Windows OSQL 
Add/Remove Type To/From Object 
Add/Remove User 
Begin/Commit/Rollback Work 
Call Function 
Change Owner 
Change Password 
Create/Delete Function 
Create/Delete Index 
Create/Delete Object 
Create/Delete Type 
Create/Delete User/Group 
Declare/Delete variables 
If/Then/Else, While, For 
Implement/Modify Function 
Open/Fetch/Close Cursor 
Raise Error 
Security On/Off 
Floating Point 
Small Integer 
Sales Offices 
For more information, call you local sales office 
listed in your telephone directory or an HP 
regional office listed below for the location of 
your nearest sales office. 
United States: 
1-800-637-7740, extension 8521 
Hewlett-Packard Ltd. 
6877 Goreway Drive 
Mississauga, Ontario L4V 1M8 
(416) 678-9430 
Yokogawa-Hewlett-Packard Ltd. 
15-7, Nishi Shinjuku 4 Chome 
Tokyo 160, Japan 
(03) 5371-1351 
Latin America: 
Latin American Region 
5200 Blue Lagoon 
Suite 950 
Miami, FL 33126 
(305) 267-4220 
Australia New Zealand: 
Hewlett-Packard Australia Ltd. 
31-41 Joseph Street 
Blackburn, Victoria 3130 
Australia (A.C.N. 004 394 763) 
(03) 895 2805 
Asia Pacific: 
Hewlett-Packard Asia Ltd. 
22/F Bond Centre, West Tower 
89 Queensway 
Central, Hong Kong 
(852) 848-7777 
Europe/Africa/Middle East: 
Hewlett-Packard S.A. 
150, Route du Nant-d'Avril 
CH-1217 Meyrin 2 
Geneva, Switzerland 
(22) 780 81 11 
Technical information in this document is subject 
to change without notice. 
All brand and product names appearing herewith are 
registered trademarks or trademarks of their 
respective holders. 
` Copyright Hewlett-Packard Company 1994.  All 
rights reserved.  Reproduction , adaptation, or 
translation without prior written permission is 
prohibited except as allowed under the copyright 
Printed in USA 7/94 

For more information, please send a message to with the subject of "index" or
"help".  If you would like to speak with someone
in person, please leave a voice mail message at
the Odapter Support, Training and Consulting number,
(408) 447-5051 and someone will get back to you
as soon as possible.

> OOFILE (A.D. Software)

OOFILE is a c++ framework. It can be used as a "traditional" ODBMS or can be
used to access a more traditional RDBMS or record-oriented database. The
current release is implemented with a Faircom c-tree Plus ISAM backend
on Mac and MS Windows. There would be very little difficulty in porting
this to any platform supported by Faircom, and we already have over 8
OS/compiler combinations in use (including 3 in-house).

Design Goals
- everything is native C++ with no (database) preprocessor required

- external interfaces to enable calling from Hypercard, Smalltalk etc.

- keep syntax very simple, familiar to 4GL users and not needing c++ gurus

- safe syntax that makes it hard to do the wrong thing by mistake, making
  maximum use of c++ compiler type-checking

- implement with a choice of database engines for the backend

- integrate with a range of common application frameworks

- provide additional classes for managing gui interfaces to help construct
  typical database applications, where features are not commonly part of
  application frameworks

- use a widely available level of c++ (no RTTI, templates or exception handling)

1) c++ developers (or wannabees) wanting an embedded database for writing
applications, probably working in combination with an application framework
such as zApp, OWL or PowerPlant.

2) World Wide Web developers seeking a database and report-writer
combination to create web pages in response to queries, searching hundreds
of thousands of records (at least).

Object-oriented design is mainly about classes, not individual objects.

OOFILE is similar. Most of the time you model your data in terms of
classes. You do NOT declare individual objects (unlike the ODMG model).

Consider a database from the user's view. They generally see collections of
data and edit or interact with individual records from the collection. The
user doesn't care about individual object identity, they don't create
symbolic names for particular objects. These things may be important inside
the database, but do not need to be exposed.

Note: for more examples, including online queries, look on

Before venturing into database definitions, let's consider some
operations on a database containing People, Job Histories and Companies.

// print my address
cout << People["Andy Dent"].Address;

// get a separate list (iterator) of people who worked for software companies
dbPeople softP( People.PrevJobs->Company->MainBusiness()=="Software" );

// for the current softP record (ie person), print the number of large companies
// where they've worked, and the current company size
cout << softP.Name() << "\t"
     << (softP.PrevJobs->Company->NumEmployees() > 100).count()
     << "\t"
     << softP.CurrentJob->Company->NumEmployees() << endl;

The () at the end of fields, as shown above, are optional for all cases except
fields in relational expressions, eg: People.CurrentJob->StartDate().

To define a table with a few fields, the simplest declaration would be:
   dbChar    Name, Address;
   dbInt     Salary;

This defaults the size of the dbChar fields to 80 chars. To specify the
size of the fields, and/or control indexing options, you need to add a
   dbChar    Name, Address;
   dbInt     Salary;

   dbPeople : Name(40, "Name", kIndexNoDups),
              Address(255, "Address"),
              Salary("Salary", kIndexed)

Note that the constructors also specify the field name strings. These
are optional, but are of great benefit when writing query and
report-writer logic or when constructing a database schema that should
be readable by others.

- Derived fields, either specified as a combination of existing fields or

- User-defined relations

- keyword indexing

- phonetic indexing

- inbuilt report-writer

One of the big features of an ODBMS is modelling the relationships between
objects. OOFILE allows you to model relations in a pure ODBMS sense, using
object identifiers, or explicitly perform runtime joins over database fields.
This would be mainly used by people porting existing database structures. There
are a number of syntaxes available to establish relationships, eg:

   dbConnect_ctree theDB;    // the physical database
   dbAcademics Academics;    // a couple of tables
   dbStudents  Students;

   dbRelation Supervision("Supervision");  // a concrete relation

   Supervision.Names("Supervises",        "is Supervised by")
              .Tables(Academics,           Students)
              .Links(Academics.Supervises, Students.Boss)
              .JoinField(Academics.StaffNo, Students.SupervisorNo);

GUI Integration classes are under development for zApp & PowerPlant with more
frameworks to follow. A "non-intrusive" approach has been taken of providing
helper classes and instructions that let you incorporate OOFILE use into an
existing program.

These helper classes include subclasses of the native edit fields, that
store data directly into the database. Depending on your framework,
other classes are added for displaying lists of records, managing
multiple page input forms and similar business application functions.

For Macintosh users, the popular AppMaker code generator is being enhanced
to generate OOFILE applications. You will be able to go from drawing your
interface to a complete working database application, without writing code.
The next AppMaker and CodeWarrior CD's will contain more information and

The current c-tree implementation is solid and the inbuilt test data generator
has been used to create databases of up to 200Mb in various configurations. The
largest beta tester is operating a 270Mb+ database on a Sparc Classic.
(500,000+ IP-flow objects as of mid July).

Product release, including (at least) zApp and PowerPlant integrations is
anticipated for September

c-tree+ v6.4B

- Symantec c++ v7.0.4
- CodeWarrior 6.1

MS Windows
- Borland c++ v4.5p3

SunOS 4.3
- g++ v2.6.3

Andy Dent
A.D. Software
94 Bermuda Drive
Ballajura, Western Australia  6066
Phone/Fax +61-9-249-2719
eWorld:      DentA
CompuServe:  100033,3241

Priority fixes/consulting rate (drop-everything mode)  $60/hour

Patches to each version - free.

Major upgrades - 30% per seat.
Annual Maintenance, regardless of number of upgrades - 40% per seat

Upgrading between database and report-writer options is at the cost difference.

Changing from one GUI to another is 50%. If you decide to later reactive the
original, it's also at 50% (ie: net result same as buying the 2nd GUI outright).

Note: if later GUI kits are at different prices, exchange rules will vary
to suit.

(Excluding bundled c-tree)
by negotiation for large sites.
40% off 2nd and subsequent copies

Andy Dent, Product Architect, A.D. Software, Western Australia
OOFILE - "the cross-platform OODBMS that speaks c++"

> Phyla

Mainstay produce Phyla, an end-user, OODB for PCs.  Includes a drag-and-drop
interface and diagrams to represent objects and their relationships.  Runs
under Macintosh System.  Listed at $500.

591 A Constitution Avenue
Camarillo, CA  93012

Voice: (805)484-9400
       1-800-484-9817  Code 6276

> POET <Persistent Objects and Extended Database Technology>  (Poet Software)

POET is a full-featured C++ ODBMS with support for, schema versioning,
check-in/check-out, online backup and object queries with OQL.
Workbenches are included for developers and administrators.  POET is
available for nearly all platforms.  OLE is supported and an ODBC
driver is available.  A single user version is sold for around $499,
and a multi-user user for mixed networks is also available.

C++ Language Support

o    tight semantic integration with C++
o    any C++ object or structure can be made persistent by adding the 
     persistent keyword
o    storing and reading a C++ object does not change its state or behavior
o    full support for C++ encapsulation, object identity,  inheritance, and 
o    C++ pointers and references are automatically converted to database 
     references when storing objects
o    database references are automatically converted to C++ pointers and 
     references when reading objects
o    all database definition is done through a small extension to C++ 
     declaration syntax

NOTE: Visual Basic support with Sourcecraft.

Database Functionality
navigation, queries, sorting, indexes, single-user operation, multi-user
operation using client/server architecture, flexible locking for objects
and sets, nested transactions, watch & notify for objects and sets,
event handling, database size limited only by hard disk size

C++ Language Extensions
persistence, indexes, transient data elements in persistent classes, sets,
dependent objects, templates

PTXX schema compiler
automatically converts extended C++ class declarations into ANSI 2.0 code,
registers classes in the class dictionary, provides class versioning

Predefined C++ Classes
date, time, strings, and BLOBS (binary large objects)

all platforms are source-code compatible, any POET database may be read by
any computer full support for heterogeneous networks

User Contributions:

Comment about this article, ask questions, or add new information about this topic:

Part1 - Part2 - Part3 - Part4 - Part5 - Part6 - Part7 - Part8 - Part9 - Part10 - Part11 - Part12 - Part13

[ Usenet FAQs | Web FAQs | Documents | RFC Index ]

Send corrections/additions to the FAQ Maintainer:
Bob Hathaway <>

Last Update March 27 2014 @ 02:11 PM