Patterns for Object / Relational
Mapping and Access Layers
If you use an object-oriented programming language like
Java, Smalltalk or C++ and a relational database as the persistent data store
you will need some form of object/relational mapping. On this site you will find various patterns
and papers about object/relational database
access layers.
We have a few tracks for different kinds of readers:
If you are
looking for a product that maps objects to relational databases
it is a good idea to have some understanding of the mechanisms behind the products. The
patterns presented and indexed here will give you an understanding of the domain, This
page is not specializing in listing all actual products but we also have a page
on products
If you prefer reading
offline, we
have two introductory articles:
Be
sure to visit the literature
section. You will find references to useful books and many free downloads
there.
If
you are looking for ways to persist Enterprise Java
Beans (EJBs) we have a set of pages on mostly
bean managed persistence
for Enterprise Java Beans (EJBs). We recommend you read it after you have
some idea of o/r access layers but I know, many will only come for the latest
stuff. After you have gone there you will return for the more advanced stuff
from 1995 :-).
All other people
with interest in
the field of mapping objects to relational databases should just continue
reading and browsing by scrolling down. You'll get a free ride worth at least 20
dollars you would otherwise spend on books :-).
In medias res ...
Object/relational persistence subsystems typically consist
of two layers.
An "object layer" should have behavior and
interfaces similar to an object-oriented database for reasons of convenience as
object oriented databases are something like the "natural extension"
of object-oriented languages with persistence features
This "object layer" will use a storage manager,
in our case a relational database that is somewhat wrapped and enhanced in order
to make the object layer's life easier.
This does not explain you very well how this all works yet.
Depending on the degree of comfort of such a persistence subsystem it may become
somewhat complex. Therefore we have split the content of this site into various
fields and chapters ...
You
should first get a picture of the context
of object/relational access layers.
We
can then present you with a deeper round trip of the general architecture
of such layers
You
will then find pointers to various patterns on the object
layer (the top layer of a persistence subsystem), the tuple layer
(part of the storage manager, if you use an RDBMS) and performance
optimization techniques which need to be used across a persistence
subsystem.
Mapping Objects to Tables and Ways to
Move Attributes to and From the
Tuple Layer are other important design field, which will show you how to do
the mapping between the object
layer and the tuple layer.
And
we will provide further web resources, some literature and a
people index.
Please
sign our guest book - your feedback will
help improve this site
Special
hint: you
can also search this site for special keywords,
using
Next page -> Context