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:
- one on persistence options for object-oriented programs (PDF) in general
- and another one on object/relational access layer patterns (PDF).
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 :-).
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