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.
Persistence generates tested, bug-free code. Using Persistence helps ensure the reliability and reusability of your applications.
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.
Code generated by Persistence is database independent. You can choose which database to work with at link step, increasing application portability.
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
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
Persistence supports inheritance of attributes, methods and relationships. - Propagate superclass queries to subclasses - Use virtual methods for polymorphism
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
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.
When a transaction is committed, Persistence walks through the object cache and writes out changes to the database.
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)
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
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)
"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: email@example.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.
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.
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.
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.
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: firstname.lastname@example.org
This document was translated by ms2html v1.8 on 01.06.95.