Object-Orientation FAQ

Persistence

                PERSISTENCE(TM): BRIDGING THE GAP BETWEEN OBJECT
                    ORIENTED DEVELOPMENT AND RELATIONAL DATA
Persistence is an application development tool which provides object
oriented access to existing relational data.  Persistence uses an
automatic code generator to convert object models into C++ classes
which know how to read and write themselves to a relational database.
Leverage existing data
Persistence enables object oriented access to existing relational
databases. Applications built with Persistence can work side by side
with legacy systems.
Automate database access
By generating the methods to convert relational data into objects,
Persistence saves the developer from having to write literally hundreds
of lines of code per class.
Speed application development
With Persistence, major changes to the application object model can be
completed in minutes, not weeks.
Quality
Persistence generates tested, bug-free code. Using Persistence helps
ensure the reliability and reusability of your applications.
Performance
At Runtime, Persistence manages an object cache to enhance performance
while ensuring data integrity. The Persistence object cache can provide
a factor of ten performance improvement for data intensive
applications.
Portability
Code generated by Persistence is database independent. You can choose
which database to work with at link step, increasing application
portability.
                        TECHNICAL SPECIFICATIONS
The Persistence Database Interface Generator converts object schemas
into C++ classes.
                                                Custom
                                                Code
                                                   |
                                                   v
Object schema    --->   Persistence    ---->    Generated
                        Generator               Classes
                                                   ^
                                                   |
                                                   v
                                                Persistence
                                                Object Cache
                                                   ^
                                                   |
                                                   v
                                                Legacy Data
Encapsulation
Each class generated by Persistence maps to a table or view in the database.
- Query using ANSI SQL or attribute values
- Add custom code to generated classes
- Preserve custom code when model changes
Inheritance
Persistence supports inheritance of attributes, methods and relationships.
- Propagate superclass queries to subclasses
- Use virtual methods for polymorphism
Associations
Persistence maps associations to foreign keys in the database. Each class has methods to access related classes.
- Ensure referential integrity between classes
- Specify delete constraints for associations
Object Caching
The Persistence Runtime Object Management System caches objects during
transactions and ensures data integrity. In the object cache,
Persistence "swizzles" foreign key attributes into in-memory pointers,
speeding object traversal.
Transactions
When a transaction is committed, Persistence walks through the object
cache and writes out changes to the database.
Environment
Platforms/Operating systems
Persistence will support all major Unix and Intel platforms
- Sun/SunOS 4.x, Solaris 2.x
- HP/HP-UX 8.0, 9.0
- IBM/AIX (planned 11/93)
- Intel/NT (planned 3/94)
Development Tools
Persistence supports all major C++ compilers and integrates with GE's
OMTool, allowing developers to go straight from an object model to a
running C++ application.
- Cfront 2.1: ObjectCenter 1.0, SPARCompiler, ObjectWorks
- Cfront 3.0: ObjectCenter 2.0, SPARCompiler, Softbench C++
- GE's OMTool
Databases
Persistence provides database independence. With our Objectivity
integration, we also provide a clear migration path to object
databases.
- Oracle V6, V7
- Sybase 4.x
- Ingres 6.x
- Objectivity ODBMS
- Informix (planned 9/93)
- ODBC (planned 3/94)
                            CUSTOMER QUOTES
"We wanted to use object technology while continuing to support our
legacy systems. Persistence made this feasible by automating over 30
percent of our development cycle." Steve Hunter, Sterling Software
"Persistence cut our development time by approximately 40%, because we
would have had to do all the mapping functions ourselves." Jim
Adamczyk, Partner, Andersen Consulting
"I'm convinced we'll save weeks or months of time because of
Persistence." Mike Kubicar, SunSoft Defect Tracking Team
"The good thing is that you can change your object model and just
re-generate the database interface classes at the press of a button."
Richard Browett, Product manager, K2 Software Developments, Ltd.
"The Persistence package saved at least 25 to 50 percent of the
development time, and seemed extremely robust. Support has been nothing
short of phenomenal." Stew Schiffman, DuPont Research and Development
                        FOR MORE INFORMATION
For more information on Persistence, please contact Carl White, VP Sales:
- By phone: (415) 341-1280
- By fax: (415) 341-8432
- By email: information@persistence.com
Persistent Data Systems
PO Box 38415
Pittsburgh, PA  15238-9925
> Subtleware
                 SUBTLEWARE(TM) FOR C++
          Connecting C++ with Relational Databases
Subtleware for C++ (Subtleware) is a software development toolset which
openly automates C++ connectivity to relational databases by providing:
*  A C++ pre-processor that automatically generates the code necessary
   to read and write C++ objects to a relational database.
*  A schema mapper that defines C++ classes from relational database
   schema, and
*  A class library that simplifies C++ application access to existing
   relational data,
SUBTLEWARE INCREASES PROGRAMMER PRODUCTIVITY
Subtleware vastly simplifies the coding necessary for C++ to work with
relational databases: 
*  It jump starts application development by generating C++ class
   definitions from relational database schema.
*  It speeds application development by eliminating the need to
   write hundreds of lines of database mapping code per class. 
*  It dramatically reduces application maintenance time by eliminating
   the need to modify the database mapping code with each C++ class
   definition change. 
As a result, C++ application developers can focus on what brings value to
their organization, application development; and, C++ application
development projects can reduce their development costs as well as speed
their time-to-market.
SUBTLEWARE IS DESIGNED TO BE OPEN
*  Subtleware adds value to your C++ development environment!
   Subtleware fits into your existing C++ development environment by
   working with your preferred C++ design tools, compilers, and class
   libraries. No Subtleware-specific design tools are necessary.
*  Subtleware works directly with your existing C++ class definitions!
*  Subtleware adds value to your relational database systems!
   Your C++ applications can work concurrently and share data with
   your other relational database applications. Subtleware makes your
   existing relational database into a powerful OODBMS.
*  Subtleware library source code and generated code is freely
   available!  No run-time fees are imposed.
SUBTLEWARE IS WIDELY AVAILABLE
Subtleware runs on a wide range of computing platforms:
*  PC's running Windows 3.x, Windows NT, OS/2, and DOS.
*  Unix workstations, including Sun and HP.
Subtleware supports a variety of database interfaces:
  *  ANSI SQL                *  ODBC
  *  Oracle                  *  Sybase
  *  Watcom                  *  Informix (planned 8/95)
  *  Ingres (planned 10/95)
  *  ODMG (planned 12/95)
Subtleware supports virtually all C++ 2.x and 3.x compilers, including:
*  Borland C++
*  Microsoft Visual C++
*  HP C++
*  SunPro C++
SUBTLEWARE IMPROVES SOFTWARE QUALITY
Subtleware generates well-documented, bug-free code. Furthermore,
Subtleware code generation can be customized for your application
requirements. Using Subtleware greatly increases the reliability and
reusability of your applications.
SUBTLEWARE OPTIMIZES APPLICATION PERFORMANCE
Subtleware generates static SQL code that can be linked directly into your
application or packaged as a DLL or shared library. Subtleware does not
require the use of high-overhead, run-time modules for managing your
persistent objects.
SUBTLEWARE PROVIDES RUN-TIME FLEXIBILITY
Subtleware offers dynamic SQL capabilities for performing run-time
specified data access.
SUBTLEWARE MAXIMIZES APPLICATION PORTABILITY
Subtleware is database independent. Your applications use the same
Subtleware API no matter which underlying database is being used.
Changing your database simply entails linking in another Subtleware
database support module to your application.
TECHNICAL DETAILS
The Subtleware pre-processor converts C++ classes to relational database
schema:
  C++ Class ------> Subtleware Pre-Processor -----> Relational Database Schema
The Subtleware SQLExec facility simplifies C++ access to existing
relation data:
  C++ Code <-------------> Subtleware SQLExec ----------> Legacy Data
The Subtleware schema mapper converts relational database schema to
C++ classes:
  Relational Schema -----> Subtleware Schema Mapper ------> C++ Class
OBJECT MODEL SUPPORT
Subtleware supports encapsulation, inheritance, containment, and polymorphism.
A C++ class is mapped to a table in a relational database. Each member
data variable (local, inherited, or contained) is mapped to a column in
the database table.
ASSOCIATION SUPPORT
Subtleware provides a set of Subtle Pointer classes for persisting one-to-
one relationships between objects. Each Subtle Pointer class offers a
unique set of behavior regarding pointer chasing and referential
integrity constraints. Subtle Pointers "swizzle" associations into in-
memory pointers, speeding object traversal.
COLLECTION SUPPORT
Subtleware provides a set of Subtle Collection classes for persisting N-
to-many relationships between objects. Each Subtle Collection class
offers a unique data structure abstraction. 
CONCURRENCY CONTROL SUPPORT
Subtleware utilizes the data locking mechanisms of the underlying
relational database. Concurrency is specified by the database isolation
level or locking protocol in-use.
TRANSACTION SUPPORT
Subtleware supports transaction commit and rollback support. When a
transaction is committed, all Subtleware database operations are
performed. When a transaction is rolled back, all Subtleware database
operations are ignored.
DEVELOPMENT TOOL SUPPORT
Subtleware supports all major C++ compilers and development
environments. Subtleware works with any C++ development tool that
generates or uses C++ header files (class definitions) and offers
customized integration with Cadre's OT for Rumbaugh, allowing
developers to go straight from an object model to a running C++
application.
FOR MORE INFORMATION
For more information on Subtleware, please contact Frank Yacano:
By phone: (617) 558-4100
By fax: (617) 558-4103
By email: subtle@world.std.com

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