Doctrine_manual-1-2-en

Chapter 1: Introduction 15
layer depends on the DBAL and therefore, when you load the ORM package the DBAL is
already included.
Doctrine Explained
The following section tries to explain where Doctrine stands in the world of ORM tools. The
Doctrine ORM is mainly built around the Active Record 2 , Data Mapper 3 and Meta Data
Mapping 4 patterns.
Through extending a specific base class named Doctrine_Record, all the child classes get
the typical ActiveRecord interface (save/delete/etc.) and it allows Doctrine to easily
participate in and monitor the lifecycles of your records. The real work, however, is mostly
forwarded to other components, like the Doctrine_Table class. This class has the typical
Data Mapper interface, createQuery(), find(id), findAll(), findBy*(),
findOneBy*() etc. So the ActiveRecord base class enables Doctrine to manage your records
and provides them with the typical ActiveRecord interface whilst the mapping footwork is
done elsewhere.
The ActiveRecord approach comes with its typical limitations. The most obvious is the
enforcement for a class to extend a specific base class in order to be persistent (a
Doctrine_Record). In general, the design of your domain model is pretty much restricted
by the design of your relational model. There is an exception though. When dealing with
inheritance structures, Doctrine provides some sophisticated mapping strategies which allow
your domain model to diverge a bit from the relational model and therefore give you a bit
more freedom.
Doctrine is in a continuous development process and we always try to add new features that
provide more freedom in the modeling of the domain. However, as long as Doctrine remains
mainly an ActiveRecord approach, there will always be a pretty large, (forced) similarity of
these two models.
The current situation is depicted in the following picture.
Relational Bounds
As you see in the picture, the domain model can't drift far away from the bounds of the
relational model.
After mentioning these drawbacks, it's time to mention some advantages of the ActiveRecord
approach. Apart from the (arguably slightly) simpler programming model, it turns out that the
strong similarity of the relational model and the Object Oriented (OO) domain model also has
an advantage: It makes it relatively easy to provide powerful generation tools, that can create
a basic domain model out of an existing relational schema. Further, as the domain model
can't drift far from the relational model due to the reasons above, such generation and
synchronization tools can easily be used throughout the development process. Such tools are
one of Doctrine's strengths.
We think that these limitations of the ActiveRecord approach are not that much of a problem
for the majority of web applications because the complexity of the business domains is often
moderate, but we also admit that the ActiveRecord approach is certainly not suited for
complex business logic (which is often approached using Domain-Driven Design) as it simply
puts too many restrictions and has too much influence on your domain model.
Doctrine is a great tool to drive the persistence of simple or moderately complex domain
models(1) and you may even find that it's a good choice for complex domain models if you
consider the trade-off between making your domain model more database-centric and
2. http://www.martinfowler.com/eaaCatalog/activeRecord.html
3. http://www.martinfowler.com/eaaCatalog/dataMapper.html
4. http://www.martinfowler.com/eaaCatalog/metadataMapping.html
----------------- Brought to you by