User manual | null User manual

US006101502A
Ulllted States Patent [19]
[11] Patent Number:
Heubner et al.
[45]
[54]
Date of Patent:
Au . 8 a 2000
OBJECT MODEL MAPPING AND RUNTIME
5,627,979
ENGINE FOR EMPLOYING RELATIONAL
5,729,739
3/1998 Cautin et al.
DATABASE WITH OBJECT ORIENTED
5,752,027
5/1998 Familiar ................................ .. 395/614
SOFTWARE
[75]
6,101,502
5/1997 Chang et al. ......................... .. 345/335
707/104
5,809,505
9/1998 Lo et al. ............................... .. 707/102
5,812,996
9/1998
Inventors: Robert A. Heubner, Tops?eld; Gabriel
Oancea, Lawrence; Robert P. Donald,
5,873,093
5,878,411
2/1999 Williamson et al.
3/1999 Burroughs et al. .
. 707/103
707/4
Methuen; JOIl E. Coleman,
5,937,409
8/1999 Wetherbee ....... ..
.. 707/103
Chelmsford, all of Mass,
5,956,725
9/1999 Burroughs et al. ................... .. 707/101
[73] Assignee: Ontos, Inc., Lowell, Mass.
Rubin et al.
........
. . . ..
707/2
Primary Examiner—Paul V. Kulik
[21] APPL No. 09/161,028
Attorney, Agent, or Firm—Weingarten, Schurgin, Gagnebin
[ 22 ]
& Hayes LLP
1 d
S ep. 2 5 1998
Fi e :
’
[57]
Related US. Application Data
[60]
ABSTRACT
_
_
_
Provisional application No. 60/069,157, Dec. 9, 1997, and
provisional application No. 60/059,939, Sep. 26, 1997.
A mappmg between an Oblect model and a relanonal data
base is generated to facilitate access to the relational data
[51]
Int. c1.7 .................................................... .. G06F 17/30
base- The Object model can be Created from database Schema
[52]
U S C]
[58] Field 01'.
707/103_ 707/104
or database schema can be created from the object model.
707/’100 104
Further, the mapping can be automatically generated. The
""""""""""""""""" "
"""""""""""""""""" "
_
’
Database schema, object model and mapping are employed
709/302
[56]
to provide interface ob'ects
that are utilized b y a runtime
J
References Cited
engine to facilitate access to the relational database by object
oriented softWare applications.
U.S. PATENT DOCUMENTS
5,291,583
3/1994 Bapat .................................... .. 395/500
18 Claims, 6 Drawing Sheets
Runtime
Engine 24
MS Transaction
Server
O
Active SQL
Application
End user I,‘
.
.
.
Stored proc
—
~o-
O
O
O
BEmp|oyee
_-->O_ DEmployee
.
HE“ —>O—
55.5
&
Business Objects
(Client side)
Data Services Layer
(Generated DLL)
OiGenBase.d|l
O
|C|ass| O
/V0_
Select SOL
Core Runtime Services
Stateless d_b Objects
rRrcore-drrr
(Wows-d")
v c'as'nm
M
Runtimelnfo
Q
.
Mapping lnformatron
(RtMap.dll)
—
U.S. Patent
Aug. 8,2000
Sheet 3 of6
6,101,502
model_packages
Modellnfo
Map 12
Packagelnfo
version:Version 1..*
package
package_classes
ancestorof
Ciasf’
1..
Classlnfo
class_inheritance
I
whereClause : String =
.c|ass_fetch_matr|x Modeunfo
dcomClasslD : Uuid
class
1‘
\/O*
I If
O..*
descendant
c ass n o
,
class_attributes
class_pnmary_key
req
attribute
Kkelyf 1
ey n o
u
A
W
key__attributes
1
Attrinfo
a TI U
?ags ; int = 0
1..* / defaultzVariant
order
*
' constraint
NamedConstraint
FIG. 4
data
1
<<enum>>
varType
(from Utl)
6,101,502
1
2
OBJECT MODEL MAPPING AND RUNTIME
ENGINE FOR EMPLOYING RELATIONAL
DATABASE WITH OBJECT ORIENTED
SOFTWARE
database structure, the database programming interface,
database security, or the database transaction model in order
to obtain access to the relational database. Further, changes
to the relational database do not alWays necessitate addi
tional mapping.
CROSS REFERENCE TO RELATED
APPLICATIONS
BRIEF DESCRIPTION OF THE DRAWING
A claim of priority is made to US. Provisional Patent
Application Serial No. 60/069,157, entitled TIER 3
DESIGN SPECIFICATION, ?led Dec. 9, 1997 and incor
porated herein by reference; and US. Provisional Patent
Application Serial No. 60/059,939, entitled DATABASE
SYSTEM ARCHITECTURE, ?led Sep. 26, 1997 and incor
porated herein by reference.
10
15
STATEMENT REGARDING FEDERALLY
SPONSORED RESEARCH OR DEVELOPMENT
N/A.
BACKGROUND OF THE INVENTION
The present invention is generally related to database
technology, and more particularly to interfacing object ori
ented softWare applications With relational databases.
The need for interfacing object oriented softWare appli
20
DETAILED DESCRIPTION OF THE
INVENTION
database is to adapt the requests made by the application to
30
result, the object oriented softWare application is unable to
function ef?ciently.
35
information into a format Which is compatible With the
object oriented application. Relational databases typically
40
maliZed relational database includes a plurality of tables,
Wherein each table includes at least one ?eld and one key,
database by performing further translations, but this process
requires substantial effort.
object oriented interface associated With an object oriented
softWare application 22 to generate interface objects 20. The
interface objects 20 are employed by the object oriented
its processing.
separate data into a plurality of tables through a process
and at least one ?eld in each table is uniquely dependent
upon the key that is associated With the table. These tables
can be translated into objects. HoWever, the objects can
become inaccurate When changes are made to the relational
database. It is knoWn to adapt to changes in the relational
Referring to FIG. 1, a mapping tool 10 is employed to
generate a map 12 in Which relationships betWeen an object
model 14 and schema associated With a relational database
16 are de?ned. Acode generator 18 is employed to eXamine
the relationships that are de?ned in the map 12 and a model
softWare application 22 to access the relational database 16
via a runtime engine 24, Which also uses the map 12 to drive
cation With a relational database is to translate database
knoWn as “normalization” to minimize duplication. A nor
FIG. 5 is an object diagram of the runtime engine;
FIG. 6 is an object diagram of RtCore.DLL; and
FIG. 7 is a sequence diagram that illustrates operation of
the runtime engine.
the relational database. More particularly, object operations
Another method of interfacing an object oriented appli
of Which:
FIG. 1 is a block diagram that illustrates use of the map
to generate interface objects that are employed by a runtime
engine and an object oriented softWare application to access
a relational database;
FIG. 2 is a block diagram of database schema;
FIG. 3 is a block diagram of an object model;
FIG. 4 is an object diagram of a mapping;
25
cations With relational databases is Well knoWn. One method
of interfacing an object oriented application With a relational
are translated into relational database queries. HoWever, this
technique is processor-intensive and sacri?ces some of the
advantages associated With the object oriented model. As a
Other features and advantages of the present invention
Will become apparent in light of the folloWing detailed
description of the draWing, in conjunction With the draWing,
The object model 14 is a template that has a predeter
mined standardiZed structure. The illustrated object model
includes attributes and inheritance relationships that are
mapped to relational database features such as tables, roWs,
columns, keys, and foreign keys. Mapping the object model
45
to the relational database schema includes mapping a class
attribute to a table column, mapping a class attribute to a 1-1,
1-N, or N-N relationship, and mapping class inheritance to
roWs Within a table or across tables.
Referring noW to FIGS. 2, 3 and 4, the mapping of a class
50 attribute to a table column can be described generally as:
Class AttributeQTable Column+Class Key+Joins. Mapping
BRIEF SUMMARY OF THE INVENTION
the class attribute de?nes Where the attributes are read from
and Written to. In the illustrated example, the class attribute
CPerson.name 26 maps to table column TPerson.name 28.
In accordance With the present invention, a mapping
betWeen an object model and a relational database and a
runtime engine are employed to facilitate access to a rela 55 The “Class Key” is employed to relate an object instance to
a roW in the table. In particular, key values of the class are
tional database. The object model can be created from
mapped to columns in a table that comprise the primary key.
database schema or database schema can be created from the
object model. Further, the mapping can be automatically
generated. The database schema, object model, and mapping
are employed to provide interface objects that are utiliZed by
60
Tperson.name, no information is required for Joins. If Cper
an object oriented softWare application to access the rela
tional database.
The present invention provides transparent access to the
relational database. The interface objects and runtime engine
perform read and Write operations on the database, including
generation of SQL code. Consequently, neither program
mers nor softWare applications need have knoWledge of the
In the illustrated example, CPerson.id 30 maps to TPerson.id
32. “Joins” de?nes keys betWeen tables Within a class. Since
there is only one table in the mapping of Cperson.name to
son includes tWo tables, such as Tperson and X, then
mapping Cperson.y to X.y includes: Cperson.y Maps to
X.y+Cperson.id Keys to Tperson.id+Tperson.id Joins to
65
X.id.
Mapping a class attribute to a 1-1, 1-N, or N-N relation
ship With at least one other object can be described generally
6,101,502
4
3
as: Class AttributeQClass+Class AttributeQForeign Key+
Joins. When an object has associations to other objects, an
TABLE 1-continued
attribute in the object points to one or multiple other objects.
If the object points to only one object, there is a one-to-one
(1-1) association betWeen the objects. If an object points to
multiple objects, there is either a one-to-many (1-N) or
In object model:
Multiple indexed tables. The table that is
mapped to the subclass has multiple keys
corresponding to each of the keys in the
superclass tables. To ensure uniqueness of
records in the subclass table, the key on the
many-to-many (N-N) relationship betWeen the objects. In
the illustrated example, CEmployee.dept 34 maps to Cde
partment 36, Where CEmployee 38 to CDepartment 36 is a
one to one relationship. “Foreign Key” represents identify
subclass table may not be de?ned as a multi
column key. If all the data of the superclass
tables is duplicated in the subclass table,
10
ing the foreign key. If CEmployee is related to CDepartment,
there is a foreign key to another table. The foreign key is
identi?ed Within one of the tables that comprise Cemployee
and is related to the class attribute Cemployee.dept. This
relationship may be inferred from foreign key information in
the database schema. It is also possible that foreign key
information is missing or that there are many foreign keys in
then no join is required to instantiate an
instance of the subclass. However, joins
Would be needed to ensure integrity of data
When performing insert, remove, and update
operations.
15
CEmployee to CDept. Consequently, this step involves
selecting columns that represent the foreign key. In the
illustrated example, Cemployee.dept is associated With
Object relationships are mapped to the database schema
by de?ning the joins needed to access related objects or
TEmployee.deptid. Once a class attribute is associated With
groups of objects (lists). The joins make use of foreign keys
the foreign key Which resides in that class, “Joins” is de?ned
to associated classes. In the illustrated example, TEmploy
de?ned in the tables that are mapped to the related classes.
ee.deptid joins to TDepartment.id is de?ned.
Mapping class inheritance to roWs Within a table or across
Can be mapped to:
25
Table 2 describes mapping of object relationships relative to
the illustrated example.
tables is performed by specifying a WHERE clause on the
class Which can distinguish the class from the associated
TABLE 2
parent class. This information is stored in the mapping
model.
Table 1 describes hoW an object model can be mapped to
structures in a database schema.
Object
Relationship:
Mapping Example:
1-1 object
Department can have only one Manager.
relationship
Department class has an object attribute (Manager)
that references only one instance of the Employee
class.
Department table has a foreign key column
(ManagerID) that references only one roW in the
TABLE 1
35
In object model:
Employee table. A join is de?ned for the Department
Can be mapped to:
class based on a unique foreign key.
A single class
All or selected columns in a table. A WHERE
clause can be associated With a class to
N-1 object
Many Employees have one Department.
relationship
The Employee class has an object attribute
(Department) that references one instance of the
specify Which roWs of the table belong to the
class.
Multiple tables that are joined by the same
Department class.
The Employee table has a foreign key column
primary key, or by a unique foreign key
(DeptID) that references one roW in the Department
relationship. If the same data is stored in
table. Ajoin is de?ned for the employee class to
multiple tables, the duplicate columns can be
handled by mapping one of the table columns
for read, and all of the columns for insert
access the one roW in the Department table that is
and update.
Multiple tables, possibly in different
referenced by the foreign key in the Employee
table.
45 1-N object
relationship
databases, Which have similar column
for the Department class that selects all roWs in
Employee that matches the current
Employees class).
Multiple tables that are unrelated in the
database, if a logical relationship can be
Single inherited
Department’s Deptid.
N-N object
de?ned in the mapping.
A single denormalized table. Columns that
relationship
An Employee can have many Projects. A project can
have many Employees.
The Employee class has a list attribute that
references a group of Projects, and the Project class
contain data for all records are typically
mapped to the superclass, and a WHERE clause
is de?ned for each subclass as a
The Department class has a list attribute (Employees)
that references the related group of employees.
Employee table has a non-unique foreign key that
references the Department table. Ajoin is de?ned
de?nitions (e.g., EastEmployees and
WestEmployees tables can be merged as a single
classes
A Department has many Employees.
55
discriminator for selecting Which roWs belong
to the given subclass.
Multiple tables that have the same primary
keys. To ensure uniqueness of records, the
primary keys of “subclass” tables may also be
de?ned as foreign keys for the “superclass”
has a list attribute that references a group of
Employees.
This mapping uses joins based on the join table that
relates the Employee table and the Project table. The
Employee class uses a join to select roWs from the
table.
Project table that match the current instance’s
Employeeid. The project class uses a join to select
roWs from the Employee table that match the current
Multiple
A single denormalized table. Different
instance’s Projectid.
inherited classes
columns are mapped to each of the classes.
Typically, there are multiple columns that can
be used as indexes. The subclass mapping has
multiple joins de?ned, Which are used to
traverse each of the inheritance
relationships.
65
Table 3 describes hoW structures in a database schema can
be mapped to structures in an object model.
6,101,502
6
5
binary ?le is generated in parallel with each DLL containing
the mapping information associated with the DLL. The
RtMap.dll 50 implements the classes that can load the
information from the binary ?le at runtime and make it
available to the runtime interface objects associated with
DLLs 56 and to the client objects 58 of the generated COM
objects through a set of prede?ned COM interfaces.
Classes OOBase and OObject in RtCore.dll 52 form the
TABLE 3
In a database
schema:
Can be mapped to:
Rows, discriminated All attributes of a single class
by WHERE clause
A single table
All attributes of a class, assuming the other
persistent attributes of the class are mapped to
columns in other tables.
Multiple classes (effectively, a vertical split
of the table)
10
A single-inherited classes (if at least one
column is appropriate for discriminating
objects implementing one of the standard IDslObject/
selection of rows for subclasses)
IDslList/IDslQlist and one or more of the client interfaces
Multiple-inherited classes (if the table has
multiple indexes)
Multiple tables,
different columns
Multiple table,
same columns
(e.g., Employee). The ATL implementation classes have
15
A single class (if the key structure exists to
join row uniquely)
Multiple classes (unrelated, unless key structure
exists to support joins)
same primary key
called the “front state” (or the front data set). The OOBase
A single class that represents a logical merge of
the tables. (NOTE: Primary key values must be
abstracting the runtime functionality for a generic object. It
Single inherited classes (each table represents a
class, keys used to de?ne joins between subclass
tables and superclass table.
contains a set of attribute info-value pairs (one per attribute,
constructed when the object is initialized to form a “back
single class (with joins based on primary key)
25
If the same data is stored in multiple tables, the duplicate
columns can be handled by mapping one of the table.col
umns for read, and all of the columns for insert and update.
relationships, either in the form of object attributes or list
attributes. In general, a foreign key in the database schema
is mapped to an inverse relationship between an object
transactional objects.
FIG. 7 illustrates the sequence of actions that take place
when a business object creates a D51 object in step 61,
accesses the name property in step 65 and saves the object
in step 69. OObject is constructed when the constructor of
attribute (on the class mapped to the table holding a foreign
35
inverse relationship between list attributes de?ned on each
Table 4 describes how relational keys are mapped to
itself. The OOBj ect initializes all ?ags and sets the attributes
to the default values as de?ned in the AttrInfo objects
object relationships relative to the illustrated example.
TABLE 4
associated with the ClassInfo in step 63. The GetAttrPtr( )
function de?ned by the OOBase is employed to get the
Corresponding Object Relationship
attribute address for each attribute in the class in order to
initialize the front set of attributes on the object in step 64.
Schema
Unique
1-only-1 object relationship represented by
Foreign Key
an object attribute with a cardinality of
45
one on the class mapped to the table that
attribute was retrieved. If the attribute was retrieved then the
cached value is returned. Otherwise, RetrieveAttrValue( ) of
the OObject is called in step 66, passing the id of the desired
attribute (name in the example). The OObject will look at the
also be mapped as an embedded type.
N-1 object relationship, represented by an
Foreign Key
object attribute on the class mapped to the
table with the foreign key, and a list
fetch matrix for this attribute and see what other attributes
should be retrieved with it in step 67 and then determines
what tables and columns are involved, how they are joined
and executes the appropriate SQL statements using the
attribute on the class mapped to the table
referenced by the foreign key.
N-N object relationship, represented by a
no other
list attribute on each of the classes mapped
data columns)
to the tables related by the join. Each
list attribute represents a collection of
Join Table (with
When the getName (propget) of the generated object is
called in step 65, the generated code checks to see if the
has the foreign key. This relationship can
Non-Unique
Join Table (with
the DPerson (the generated COM implementation class) is
invoked in step 62. The constructor passes as parameters the
appropriate constant ClassInfo reference and a reference to
of the classes mapped to the tables related by the join table.
Relationship
state,” or baseline). OObject also has a set of attribute ?ags
(one per attribute, bitwise or of values like isModi?ed,
isRetrieved, isDirty, isNull and others). One instance of the
OObject is created for every instance of the generated
objects to take care of the interface to the persistent data
storage through a set of DB objects that are MTS stateless,
Schema relationships are mapped directly to object
key) and a list attribute (on the class mapped to the table
referenced by a foreign key). A join table is mapped to an
state implemented as a set of attributes of the primitive types
contains a pointer to the OObject and a public pure virtual
method to access the address of each attribute in the classes
descending from itself. The attributes are indexed according
to the class de?nition for the object. The OObject class is
unique between the tables.)
Multiple tables,
core of the runtime engine 24. The OOBase is a base abstract
class which is used as a base for all the generated imple
mentation classes. The generated classes are ATL COM
55
references to objects of the other type.
A class mapped to the join table, AND a N-N
additional data
object relationship, represented by a list
columns)
attribute on each of the classes mapped to
stateless MTS object. The GetAttrPtr( ) function de?ned by
the OOBase is employed to get the attribute address for each
attribute in the class in step 68.
When the object is saved in step 69, the generated code
calls the OObject SaveChange( ) method in step 70. The
OObject determines what attributes have changed and,
the tables related to the join.
depending on the concurrency control mode in effect, makes
sure the appropriate locks and transactions are set and
Referring to FIGS. 5 and 6, the runtime engine comprises
a plurality of dynamic link libraries (“DLLs”) including:
respectively open and then executes the appropriate SQL to
write the data to the persistent storage in step 71.
RtMap.dll 50, RtCore.dll 52, DbObjs.dll 54, OiGenBase.dll
57, and a set of generated DLLs 56. The generated DLLs 56
contain one COM interface and implementation class for
each class de?ned by a mapping model. A mapping model
65
Referring again to FIGS. 1—4, the runtime engine also
includes a plurality of performance enhancing features such
as optimized data retrieval algorithms. An attribute retrieval
6,101,502
8
7
can be associated With each attribute to optimize attribute
retrieval from the database. As a default case, all attributes
utiliZing a runtime engine Which invokes said at least one
interface object With the object oriented application to
are retrieved When any one of an object’s attributes are
needed. HoWever, the attribute retrieval list for any attribute
can be edited to specify different attribute retrieval behavior.
For example, a request for an Employee Id may cause the
Photo attribute to be dropped from the attribute retrieval list
on the Id attribute if that data resides in another table and is
only infrequently used. Attribute retrieval lists are a perfor
mance feature that enable optimiZed data access by only
doing JOINS and additional SELECT statements When the
data returned by those actions is needed.
access data from the relational database.
2. The method of claim 1 further including the step of
mapping a class attribute to a table column.
3. The method of claim 1 further including the step of
mapping a class attribute to a 1-1 relationship.
4. The method of claim 1 further including the step of
10
5. The method of claim 1 further including the step of
Performance is also enhanced by “just in time” data
retrieval. By default, Whenever an attribute value is read
from the database, all of the other attributes for that instance
are also read. HoWever, Data Component Developers are
permitted to modify the mapping information for a Data
Component to de?ne an attribute retrieval group for each
attribute of a class that determines Which other attribute
values are returned When the requested attribute is read from
the database. This makes it possible to avoid executing
mapping a class attribute to a 1-N relationship, Where N is
an integer that is greater than 1.
mapping a class attribute to an N-N relationship, Where N is
an integer that is greater than 1.
15
6. The method of claim 1 further including the step of
mapping class inheritance to roWs Within a table.
7. The method of claim 1 further including the step of
mapping class inheritance across a plurality of tables.
8. The method of claim 1 further including the step of
creating a plurality of said interface objects.
9. The method of claim 8 further including the step of
J OINs or SELECTs to retrieve data that may not be needed.
For example, assume that a class, CPerson, has four
creating at least one stateful interface object and at least one
attributes: Id, Name, Zip, and Photo, and the Photo attribute
stateless interface object.
is mapped to a column in a different table from the others.
The Data Component Developer may drop Photo from the
25
group of attributes that are retrieved When either Id, Name,
or Zip are read. A query is issued to get the Name and Id of
10. A computer program ?xed on a computer-readable
medium and adapted to operate on a computer to provide
access to a relational database for an object oriented soft
Ware application, comprising:
a instance of CPerson Where Id=10. Based on the attribute
retrieval information, the run time engine retrieves only the
values for the person.id, person.name, and person.Zip
attributes, thus avoiding an unnecessary join to return the
a mapping routine that generates a map of at least some
photo attribute value as Well.
a code generator that employs said map to create at least
one interface object associated With an object corre
sponding to a class associated With the object oriented
relationships betWeen schema in the database and a
selected object model;
If an object does not have an attribute in memory When an
attempt is made to use that attribute, the object Will issue a
SELECT statement to retrieve the attribute from the data 35
base. “Just-in-time” attribute population alloWs the object to
be populated With the minimal amount of information nec
essary for the application While still making any remaining
information available When it is needed.
LaZy reads are also employed to enhance runtime perfor
mance. When a query is de?ned to identify objects for
retrieval from the database, the SQL SELECT statement is
not issued immediately. Queries are executed only after an
attempt has been made to use or modify the resulting data.
Having described the embodiments consistent With the
present invention, other embodiments and variations con
sistent With the present invention Will be apparent to those
skilled in the art. Therefore, the invention should not be
11. The program of claim 10 Wherein said mapping
routine is operative to map a class attribute to a table
column.
12. The program of claim 10 Wherein said mapping
routine is operative to map a class attribute to a 1-1 rela
tionship.
13. The program of claim 10 Wherein said mapping
45
routine is operative to map a class attribute to an N-N
relationship, Where N is an integer that is greater than 1.
15. The program of claim 10 Wherein said mapping
should be vieWed as limited only by the spirit and scope of
the appended claims.
routine is operative to map class inheritance to roWs Within
What is claimed is:
1. A method for interfacing an object oriented softWare
a table.
16. The program of claim 10 Wherein said mapping
application With a relational database, comprising the steps
routine is operative to map class inheritance across a plu
55
selecting an object model;
generating a map of at least some relationships betWeen
schema in the database and the selected object model;
employing the map to create at least one interface object
associated With an object corresponding to a class
associated With the object oriented softWare applica
tion; and
routine is operative to map a class attribute to a 1-N
relationship, Where N is an integer that is greater than 1.
14. The program of claim 10 Wherein said mapping
vieWed as limited to the disclosed embodiments but rather
of:
softWare application; and
a runtime engine that invokes said at least one interface
object to access data from the relational database.
rality of tables.
17. The program of claim 10 Wherein said code generator
is operative to create a plurality of said interface objects.
18. The program of claim 17 Wherein said code generator
is operative to create at least one stateful interface object and
at least one stateless interface object.
UNITED STATES PATENT AND TRADEMARK OFFICE
CERTIFICATE OF CORRECTION
PATENT NO.
DATED
: 6,101,502
: August 8, 2000
INVENTOR(S)
: Robert A. Huebner et 211.
Page 1 of l
It is certified that error appears in the above-identified patent and that said Letters Patent is
hereby corrected as shown below:
Title page,
In the heading, “Heubner et al.”, should read -- Huebner et a1. --; and
Item [75], Inventors, '“Robert A. Heubner”, should read -- Robert A. Huebner --.
Signed and Sealed this
Twentieth Day of November, 2001
Arrest:
WM f?
NICHOLAS P. GODICI
Attesn'ng O?icer
Acting Director ofthe United States Patent and Trademark Oj?ce
UNITED STATES PATENT AND TRADEMARK OFFICE
CERTIFICATE OF CORRECTION
PATENT NO.
: 6,101,502 C1
Page 1 of 1
APPLICATION NO. : 90/008452
DATED
: November 10, 2009
INVENTOR(S)
: Huebner et a1.
It is certified that error appears in the above-identified patent and that said Letters Patent is hereby corrected as shown below:
On the front of the EX Parte Reexamination Certi?cate, at item 73 for Assignee,
delete “Firestar Software, Inc, Framingham, MA (US)” and insert --DataTem, Inc.,
New York, NY (US)-
Signed and Sealed this
Sixteenth Day of March, 2010
David J. Kappos
Director of the United States Patent and Trademark Of?ce
US006l0l502Cl
(12) EX PARTE REEXAMINATION CERTIFICATE (7148th)
United States Patent
(10) Number:
US 6,101,502 C1
Huebner et a].
(54)
OBJECT MODEL MAPPING AND RUNTIME
4,930,071
4,953,080
4,989,132
5,008,853
5,010,478
5,079,695
5,093,914
5,113,522
5,125,091
5,129,083
5,129,084
5,136,712
ENGINE FOR EMPLOYING RELATIONAL
DATABASE WITH OBJECT ORIENTED
SOFTWARE
(75) Inventors: Robert A. Huebner, Tops?eld, MA
(US); Gabriel Oancea, Lawrence, MA
(US); Robert P. Donald, Methuen, MA
(US); Jon E. Coleman, Chelmsford, MA
(Us)
A
A
A
A
A
A
A
A
A
A
A
A
5/1990
8/1990
1/1991
4/1991
4/1991
1/1992
3/1992
5/1992
6/1992
7/1992
7/1992
8/1992
(73) Assignee: Firestar Software, Inc., Framingham,
FOREIGN PATENT DOCUMENTS
Reexamination Request:
No. 90/008,452, Jan. 25, 2007
CA
W0
W0
Reexamination Certi?cate for:
Patent No.:
6,101,502
Issued:
Appl. No.:
Filed:
Aug. 8, 2000
09/161,028
Sep. 25, 1998
Tou et a1.
Dysart et al.
Mellender et al.
Bly et a1.
Deran
Dysart et al.
Coplien et al.
Dinwiddie, Jr. et al.
Staas, Jr. et al.
Cutler et al.
Kelly, Jr. et a1.
PeraZZoli, Jr. et al.
(Continued)
MA (US)
2147421
W0 97/ 07470
99/ 09494
10/1995
2/ 1997
2/1999
OTHER PUBLICATIONS
http://www.pcmag.com/encyclopediaiterm/0,2542,t=run
time+engine&i=56079,00.asp.*
Microsoft Press. Computer Dictionary. 3rd Edition, pp.
Certi?cate of Correction issued Nov. 20, 2001.
4484449. 1997.*
Arthur M. Keller, Richard Jensen and Shailesh Agarwal,
Related U.S. Application Data
Persistence Software: Bridging ObjectiOriented Program
(60)
Provisional application No. 60/069,157, ?led on Dec. 9,
(51)
Int. Cl.
-
1997, and provisional application No. 60/059,939, ?led on
-
i
Hung and Relanonal Databases’ pp' 523 528 (1993)’
Sep' 26’ 1997’
(Continued)
_
G06F 1 7/30
Nov. 10, 2009
(45) Certi?cate Issued:
(200601)
_
Primary ExammeriDeandra M Hughes
(57)
ABSTRACT
(52)
U.S. Cl. ............................... .. 707/103 R; 707/104.1
(58)
Field of Classi?cation Search ...................... .. None
A mapping between an Object model and a relational data
See application ?le for Complete Search history
References Cited
base is generated to facilitate access to the relational data
base. The object model can be created from database schema
or database schema can be created from the object model.
US‘ PATENT DOCUMENTS
Further, the mapping can be automatically generated. The
Database schema, object model and mapping are employed
(56)
4,525,780 A
4,853,843 A
4,864,497 A
@1985 Bran et al‘
8/1989 Ecklund
9/ 1989 Lowry et al.
to provide interface objects that are utilized by a runtime
engine to facilitate access to the relational database by object
oriented software applications.
Runiime
Engine 24
MS Transaciion
Sewer
O
22
Application
0
O
m
O
4c»
'
V
,2
f MP":
?i
0
'
I
Q
4*
&
Bui
/
.
cuehlniimsefvim
m...)
Siatelessdbobpcls
(“Wis-d")
&
Ob’ cis
DmSeMoesLayer
isms-.15
(Gmemied nu)
9355"”
0iGenBase.dll
°—-
Runti
lnio
a
m
Mapping lnfomiaiion
(Rivapnn)
US 6,101,502 C1
Page 2
US. PATENT DOCUMENTS
5,142,674
5,157,777
5,161,223
5,161,225
5,170,446
5,175,848
5,185,885
5,187,786
5,187,787
5,187,790
5,191,522
5,193,180
5,206,951
5,212,787
5,227,967
5,235,701
5,265,206
5,283,894
5,291,583
5,291,593
5,295,256
5,295,259
5,315,709
5,327,559
5,369,761
5,386,564
5,388,264
5,499,371
5,504,885
5,542,078
5,586,311
5,596,746
5,615,362
5,627,979
5,659,723
5,694,597
5,694,598
5,696,961
5,701,453
5,706,506
5,717,924
5,727,203
5,729,739
5,734,887
5,737,597
5,752,027
5,761,656
5,765,162
5,778,375
5,809,505
5,812,996
5,819,086
5,829,006
5,850,544
5,857,197
5,873,093
5,875,333
5,878,411
5,893,108
5,897,634
5,924,100
5,937,402
5,937,409
5,956,725
5,956,730
5,977,967
6,047,284
6,061,515
6,076,090
6,078,926
8/1992
10/1992
11/1992
11/1992
12/1992
12/1992
2/1993
2/1993
2/1993
2/1993
3/1993
3/1993
4/1993
5/1993
7/1993
8/1993
11/1993
2/1994
3/1994
3/1994
3/1994
3/1994
5/1994
7/1994
11/1994
1/1995
2/1995
3/1996
4/1996
7/1996
12/1996
1/1997
3/1997
5/1997
8/1997
12/1997
12/1997
12/1997
12/1997
1/1998
2/1998
3/1998
3/1998
3/1998
4/1998
5/1998
6/1998
6/1998
7/1998
9/1998
9/1998
10/1998
10/1998
12/1998
1/1999
2/1999
2/1999
3/1999
4/1999
4/1999
7/1999
8/1999
8/1999
9/1999
9/1999
11/1999
4/2000
5/2000
6/2000
6/2000
6,085,198
6,108,664
6,122,627
6,134,540
6,163,776
Barker et al.
Lai et al.
Abraham
Abraham et al.
Sullivan et al.
6,173,290 B1
6,175,837
6,223,227
6,226,637
6,240,422
6,374,252
6,385,618
6,466,992
6,704,744
6,952,706
7,127,474
Dysart et al.
Dysart et al.
Densmore et al.
Skeen et al.
East et al.
Bosco et al.
Hastings
Khoyi et al.
Baker et al.
Bailey
Ohler et al.
Shackelford et al.
Deran
Bapat
Abraham et al.
Bapat
Horne
A
A
A
A
A
B1
B1
B1
B1
B1
B1
B2
B1
B2
B2
7/2000
8/2000
9/2000
10/2000
12/2000
Skinner et al.
Nori et al.
Carey et al.
Carey et al.
Periwal
1/2001 Goldberg
1/2001
4/2001
5/2001
5/2001
4/2002
5/2002
10/2002
3/2004
10/2005
10/2006
Sharma et al.
Williamson et al.
Carey et al.
Atkins et al.
Althoff et al.
Ng et al.
Williamson et al.
Williamson et al.
Williamson et al.
Williamson et al.
OTHER PUBLICATIONS
InfoBase Software Speci?cation, pp. 14121 (1990).
InfoBase User Manual, pp. 1450 (1989).
Weiyi Mang, Clement Yu, Wong Kim, Gaoming Wang,
Tracy Pham and Son Dao, Construction of a Relational
Priven et al.
Frontiend for ObjectiOriented Database Systems, pp.
4764483 (1993).
Conley et al.
Michael R. Blaha, William J. Premerlani, and James E.
Shearer et al.
Rumbaugh, Relational Database Design Using an ObjectiO
riented Methodology, pp. 4144427 (1988).
Alston, Jr. et al.
Tobias, II et al.
Henninger et al.
Alashqur
Martel et al.
Davies et al.
Shen et al.
Jensen et al.
Chang et al.
Dimitrios et al.
Cantin et al.
Durand et al.
Briscoe et al.
Maloney et al.
C. SouZa dos Santos and E. Theroude, Persistent Java, pp.
1422 (1996).
Red Hat, Inc. & Red Hat MiddleWare, LLC, Defendants Red
Hat, Inc. and Red Hat MiddleWare, LLC’S Invalidity Con
tentions, litigation document, Aug. 6, 2007, pp. 1441, United
States District Court For The Eastern District of Texas Mar
shall Division.
Red Hat, Inc. & Red Hat MiddleWare, LLC, Defendants Red
Hat, Inc. and Red Hat MiddleWare, LLC’S Supplemented
Invalidity Contentions, litigation document, Feb. 7, 2008,
Jensen et al.
pp. 14266 (including the Exhibits), United States District
KaWai
Hapner et al.
Court For The Eastern District of Texas Marshall Division.
Civil Action No. 2z06£Vi258 (TJW), entitled as “Joint
Cantin et al.
Claim Construction and Prehearing Statement,” pp. 147.
Kingberg et al.
Civil Action No. 2z06iCVi258 (TJW), entitled as “Firestar
SoftWare, Inc’s Claim Construction Brief Pursuant to
Blackman et al.
Familiar
Ben-Shachar
Blackman et al.
Hecht
Lo et al.
Rubin et al.
Kroenke
P.R.4*5(a)” pp. 1435 (excluding exhibits).
Civil Action No. 2z06iCVi258 (TJW), entitled as “Red
Hat’s Claim Construction Brief’ pp. 1434.
Civil Action No. 2z06iCVi258 (TJW), entitled as “Firestar
SoftWare, Inc.’s Reply Brief Pursuant to P.R.4*5(c)” pp.
Parvathaneny et al.
Parvathaneny et al.
1417.
Civil Action No. 2z06iCVi258 (TJW), entitled as “Red
Mullins
Williamson et al.
Fish et al.
Rotterdam, Ernest, OORL: A Declarative and Object Ori
Hat’s SuriReply Brief Regaring Claim Construction” pp.
147.
Burroughs et al.
ented Database Language (Aug. 8, 1995).
Srinivasan et al.
Attaluri et al.
Presentations of the OOPSLA ’95 Workshop: Objects and
Chang et al.
Relational Databases, (Oct. 16, 1995).
Pandit
Wetherbee
Abiteboul, Serge, O2 Java ODMG Binding Presentation,
Burroughs et al.
Burroughs et al.
Application Devlopment4Oracle Plans to Pave Object Path
Berner et al.
Owens et al.
May 23, 1997 (“JRB Presentation”).
With Sedona Project, InfoWorld Publishing Company (Aug.
13, 1995).
Chang et al.
Burroughs et al.
Barsalou, Thierry, et al., Complex Objects for Relational
Databases, Computer Aided Design, vol. 22, No. 8 (“Com
Jensen et al.
plex Objects”).
US 6,101,502 C1
Page 3
Barsalou, Thierry, et al., KnowledgeiDirected Mediation
Kyriakakis, Ted, Subtleware Post (Feb. 8, 1994 (“Subtleware
Between Application Objects and Base Data, Data Knowl
Post”).
edge Base Integration: Proceedings of the Working Confer
ence (“KnowledgeiDirected Mediation”).
Barsalou, thierry, et al., Updating Relational Databases
Through ObjectiBased Views, AM SIGMOD International
Conference on Management of Data, vol. 20, No. 2 (“Updat
ing Relational Databases”).
Campbell, The Object Oriented Design and Implementation
Law, Kincho et al., Managing Design Objects in a Sharable
Relational
Framework
(1990)
(“Managing
Design
Objects”).
Law, Kincho, Management of Complex Structural Engineer
ing Objects in a Relational Framework, Engineering with
Computers, Issue 6 (1990) (“Complex Structural Engineer
ing Objects”).
of a Rlational Database Management System.
Lee, B. et al., “Ef?ciency instantiating viewiobjects from
Core Functionality for Object to Relations Maps, Oracle
remote relational databases,” The International Journal on
Corporation (1996).
Very Large Data Vases, vol. 3, No. 3, pp. 289*323 (“Lee
VLDB 1994”).
Lee, B. et al., Outer joins and ?lters for instantiating objects
from relational databases through views, IEEE Transactions
on Knowledge and Data Engineering (Feb. 1994) vol. 6, No.
1 p. 108*19 (“Lee IEEE 1994”).
Manola, Frank Integrating Object Oriented Applications and
Middleware with Relational Databases, GTE, Laboratories,
Inc. (“Manola”).
“Marketing Brief on Java Blend” (Mar. 20, 1997).
Data Access Builder (“DAX Builder”).
Data Access Builder Implementation Overview (“DAX
Implementation Overview”).
Data Access Builder Window (“DAX Builder Window”).
Documentation relating to Pocket (1996*1997), produced
by Sun under separate cover.
Enterprise Object Framework Developer’s Guide: NeXT
Step Developer’s Library.
Enterprise Objects Framework Developer’s Guide: Open
Step Developer’s Library, NeXT Computer, Inc. (1996)
(“OpenStep Developer’s Library”).
Fishman, D.H., et al., “IRIS: An ObjectiOriented Database
Management System,” ACM Transactions on O?ice Infor
mation Systems, vol. 5, No. 1 (“Fishman ’87”).
Fitsilis, P., Producting Relational Database Schemata from
an Object Oriented Design, IEEE (1994) (“Producing Rela
tional Database Schemata”).
Gardarin, Georges, et al. Managing Complex Objects in an
Extensible Relational DBMS, Proceedings of the Fifteenth
International Conference on Very Large Data Bases pp.
5556 (“Gardarin 1989”).
InfoBase for Smalltalk *80 Release 1.0 External reference
Speci?cation, Rev. 2.2 (“Infobase ERS”).
InfoBase User’s Manual, ParcPlace Systems, Inc. Rev. 4
(“InfoBase Manual”).
Introduction to TOPLink Version 2.1 (“TOPLink for Small
Talk v. 2.1 Manual”).
Java Blend/Pocket (“Java Blend/Pocket”).
Java Blend source code (1996*1997).
John Petrie, “Object Integration Server” Presentations of
OOPSLA ’95 Workshop Objects and Relational Databases
(“ONTOS OIS Presentation”).
John Petrie, “ONTOS Object Integration Server (ONTOS
NeXTStep Enterprise Objects Framework Developer’s
Guide: NeXTStep Developer’s Library, Release 3 (1994).
Novera EPIC DB Blend (“Novera”).
O2 Java Relational Binding, at http://web.arquive.org/
1997022231614/http://www.o2tech.fr/ (Feb. 26, 1996) (“O2
JRB Website”).
“Object/Relational Integration: ONTOS Object Integration
Server” Advertisement (May 1996).
ONTOS Object Integration Server for Relational Databases
1.0: Schema Mapper User’s Guide, (ONTOS, Inc.
1989*1994) (Nov., 1994), Proceedings of the OOPSLA ’95
Workshop: Objects and Relational Databases, (Oct. 16,
1 995).
ONTOS OIS for Relational Databases 1.0: Schema Mapper
User’s Guide (“ONTOS SMUG”).
Oracle7 Server SQL Reference Manual: Elements of
Oracle7 SQL (“Oracle Elements”).
Oracle7 Server SQL Reference Manual: Commands
(“Oracle Commands”).
Oracle Floats Plan, Computerworld via First! By Individual,
Inc. (Feb. 19, 1995).
Oracle’s public deminstrations of the product in 1996.
Persistence Demonstration for SIGMOD ’93 (“Persistence
OIS): Integrating Objects with Relational Databases Techni
Video”).
cal Overview” Proceedings of the OOPSLA ’95 Workshop
Objects and Relational Databases (“ONTOS OIS Technical
sistence User Manual, Version 1.2 (Persistence Software
Overview”).
Joss Object Services Persistence Service Speci?cation,
OMG TC No. 93.113 (“JOSS”).
Kelley, W. et al., “Schema Architecture of the UniSQL/M
Multidatabase System,” Modern Database Systems: The
Object Model, Interoperability, and Beyond (“UniSQL/M
Schema Architecture”).
Kleindienst, Jan, et al., “Lessons Learned from Implement
ing the CORBA Persistent Object Service” OOPSLA ’96
(“Kleindienst”).
Kleissner, Charly “Enterprise Objects Framework: A Second
Persistence Demonstration for SIGMOD ’93 Video, and Per
1992) (Mar. 1993).
Persistence
User
ManualiVersion
1.2 (“Persistence
Manual”).
Proceedings of the OOPSLA ’95 Workshop: Objects and
Relational Databases, (Oct. 16, 1995).
Proll, Elisabeth, Design of a Meta Data Base for Mapping
Complex Objects in a Relational Data Base (“COMan The
sis” .
Reinwald, Storing and Using Objects in a Relational Data
base, IBM Systems Journal, vol. 35, No. 2 (“Reinwald”).
Rowe, L., “A Shared Object Hierarchy,” (Revised) (“Rowe
Generation ObjectiRelational Enabler” SIGMOD, Jun.
’87”).
1995 (“Kleissner EOF”).
Sedona Build 092 Oracle Corp. (“Sedona Code”).
Sedona Product Demonstration (“Sedona Product Demo”).
Klug, A., et al., “Multiple View Support within the ANSI/
SPARC Framework,” Proceedings of the Third International
Conference on Very Large Databases (“Klug”).
Sedona v. 1.00 Installation and Release Notes, (Oracle Cor
poration 1996).
US 6,101,502 C1
Page 4
SouZa dos Santos, C., Persistent Java, First International
Workshop on Persistence and Java (“Persistent Java”).
Srinivasan, V., Object Persistence in Object Oriented Appli
cations, IBM Systems Journal, vol. 36, No. 1, 66*87 (“Srini
TOPLink Java Version 1.0 User’s Manual (“TOPLink for
Java V 1.0 Manual”).
TOPLink Smalltalk Version 2.0 User’s Manual (“TOPLink
for SmallTalk V. 2.0 Manual”).
vasan Persistence”).
Verona Applications Requirements & Applications Frame
SubtleWare for C++/Oracle: User Guide (1993*1995)
Work Strategy (“Verona Framework”).
(“SubtleWare Users Guide”).
SubtleWare, Demonstration Guide (1995) (“SubtleWare
Demonstration Guide”).
Sujanski, Walter, Structural Semantics and Complex Objects
Verona Major Features Design Document: Applications
for the Coupling of Relational Databases and Knowledgei
Based Systems, (1990) (“Coupling Relational Databases and
KnowledgeiBased Systems”).
Thelen, F. et al., “POET SQL Object Factory: Technical
OvervieW” (“POET”).
TOPLink for Smalltalk Version 2.0 distributed code
(“Toplink forV 2.0 Code”).
TOPLink for SmallTalk Version 4.0 Manual (TOPLink for
SmallTalk V. 4.0).
Technology ObjectiOriented Applications (“Verona Major
Features”).
Visual Works Object Reference, Rev. 1.1 (“VisualWorks
Object Reference”).
Visual Works User’s Guide, Rev. 2.0 (“VisualWorks User’s
Guide”).
Wiederhold, Gio, et al., “Integrating Data into Objects Using
Structural Knowledge,” Third International Symposium on
Command and Control Research and Technology, National
Defense University (“Integrating Data into Objects”).
* cited by examiner
US 6,101,502 Cl
1
EX PARTE
REEXAMINATION CERTIFICATE
ISSUED UNDER 35 U.S.C. 307
2
from the object oriented software application, wherein the
relational database access functionality includes reading
and writing data.
3]. The computer program of claim 28 wherein said at
least one shared library includes at least one dynamic link
NO AMENDMENTS HAVE BEEN MADE TO
THE PATENT
library (DLL).
32. The method ofclaim 1 wherein said utilizing isfurther
defined as the object oriented software application invoking
AS A RESULT OF REEXAMINATION, IT HAS
BEEN DETERMINED THAT:
at least one interface object to request data from the rela
tional database corresponding to at least one attribute of at
least one object corresponding to a class associated with the
The patentability of claims 1418 is con?rmed.
object oriented software application.
NeW claims 19444 are added and determined to be patent
able.
33. The method ofclaim 32 wherein said utilizing isfur
ther defined as at least one interface object invoking the
19. The method ofclaim ]further comprising reading the
runtime engine to obtain data requested by the object ori
map with the runtime engine to at least one of read data
from and write data to the relational database.
20. The method ofclaim 19 wherein the reading the map
comprises loading informationfrom the map at runtime.
21. The method ofclaim ]further comprising creating an
instance ofa runtime engine class by the runtime engine to
abstract relational database access functionality from the
ented software application.
34. The method ofclaim 33 wherein said utilizing isfur
ther defined as at least one interface object calling a method
on a runtime engine object.
20
obtain the data requested by the object oriented software
object oriented software application, wherein the relational
database accessfunctional ity comprises reading and writing
data.
22. The method of claim 2] wherein the creating com
application.
36. The method ofclaim 35 wherein said utilizing isfur
25
be accessed to obtain the data requested by the object ori
ented software application.
23. The method ofclaim 19further comprising generating
mapping informationfrom the map, wherein the generating
37. The method ofclaim 35 wherein said utilizing isfur
30
38. The method ofclaim 33 wherein said utilizing isfur
runtime engine.
24. The method ofclaim 23 wherein reading the mapfur
ther comprises loading informationfrom one or more map
ther defined as the runtime engine invoking at least one
interface object to deliver the data requested by the object
35
object model corresponding to the object oriented software
application.
40. The method of claim 39 further defined as creating
40
schema in the database.
42. The method ofclaim 41further defined as creating the
object model corresponding to the object oriented software
modify the particular data by the software application,
45
engine comprises invoking at least one interface object after
reading the map with the runtime engine.
28. The computerprogram ofclaim 10 wherein said runt
ime engine comprises at least one shared library.
29. The computer program of claim 28 wherein said at
least one shared library includes executable loading code
for the loading mapping informationfrom the map.
30. The computer program of claim 28 wherein said at
least one shared library includes executable abstracting
codefor abstracting relational database accessfunctional ity
schema in the database based on the object model.
4]. The method of claim 1 further defined as creating
a query by the runtime engine to one of retrieve or store
particular data after detecting a need to one of use or
wherein executing the query occurs after reading the map.
27. The method ofclaim 19 wherein utilizing the runtime
oriented software application.
39. The method of claim 1 further defined as creating the
25. The method ofclaim ]further comprising executing a
query by the runtime engine to one of retrieve or store par
ticular data after detecting a need to one of use or modify
the particular data by the software application.
26. The method ofclaim 19further comprising executing
ther defined as the runtime engine invoking at least one
database object to execute a database query.
at least one mapping model?le occurs prior to utilizing the
ping model?les by the runtime engine.
ther defined as the runtime engine reading the map to deter
mine at least one table and at least one column that needs to
prises creating one instance ofthe runtime engine class by
the runtime engine for every interface object instance.
at least one mapping model file containing at least some
35. The method ofclaim 33 wherein said utilizing isfur
ther defined as the runtime engine accessing the database to
application based on schema in the database.
43. The computer program ofclaim 10 wherein the runt
ime engine includes a runtime engine class for defining at
least one method to abstract relational database access
functionality from the object oriented software application,
50
and wherein the relational database access functionality
comprises reading and writing data.
44. The computer program of claim 43 wherein an
instance ofthe runtime engine class is createdfor each inter
face object instance.

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project