Libertyvasion2010

Doctrine 2.0
Enterprise Object Relational Mapper for PHP 5.3

Doctrine 2.0 www.doctrine-project.org www.sensiolabs.org

Jonathan H. Wage
• Web developer for over a decade
• Tech junky for even longer
• Open Source Evangelist
• Published Author
• Contributes to...
• ...Doctrine
• ...Symfony
• ...and more
• Works full-time for Sensio Labs


Jonathan H. Wage
• http://www.twitter.com/jwage
• http://www.jwage.com
• http://www.facebook.com/jwage

You can contact Jonathan about Doctrine and Open-Source or for
training, consulting, application development, or business related
questions at jonathan.wage@sensio.com


Project History
• First commit April 13th 2006

• First stable version ﬁnished and Released September
1st 2008

• One of the ﬁrst ORM implementations for PHP

• 1.0 is First LTS(long term support) release.
Maintained until March 1st 2010

• Integrated with many popular frameworks: Symfony,
Zend Framework, Code Igniter, etc.

The Team
• Roman S. Borschel

• Guilherme Blanco

• Benjamin Eberlei

• Bulat Shakirzyanov

• Jonathan H. Wage


Object Relational Mapper
What is it?


Object-relational mapping (ORM, O/RM, and O/R
mapping) in computer software is a programming
technique for converting data between incompatible type
systems in object-oriented programming languages. This
creates, in effect, a "virtual object database" that can be
used from within the programming language. There are
both free and commercial packages available that
perform object-relational mapping, although some
programmers opt to create their own ORM tools.


Doctrine1 vs Doctrine2


The Doctrine1 Way

class User extends Doctrine_Record
{
public function setTableDefinition()
{
$this->hasColumn('username', 'string');
$this->hasColumn('password', 'string');
}
}


The Doctrine1 Way

$user = new User();
$user->setUsername('jwage');
$user->setPassword('password');
$user->save();


Problems
• Domain is bound to persistence layer
• Complexity of domain entities limited by
persistence layer

• $model->save() is a bottle neck for persisting
large numbers of objects

• Testing your domain model requires mocking
the persistence layer


The Doctrine2 Way
How does Doctrine2 do it?


No base class to extend


/**
* @Entity
* @Table(name="users")
*/
class User
{
/**
* @Id
*/
private $id;

/**
* @Column(type="string", length=255)
*/
private $username;

public function setUsername($username)
{
$this->username = $username;
}

// ...
}


Mapping Information
Specify your mapping information with XML, YAML or
DocBlock Annotations


YAML
User:
type: entity
table: users
fields:
id:
type: integer
id: true
generator:
strategy: AUTO
username:
type: string(255)
password:
type: string(255)


XML

<?xml version="1.0" encoding="utf-8"?>
<doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-
mapping" xsi="http://www.w3.org/2001/XMLSchema-instance" schemaLocation="http://
doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
<entity name="User" table="users">
<id name="id" type="integer" column="id">
<generator strategy="AUTO"/>
</id>

<field name="username" type="string" column="username" length="255" />
<field name="password" type="string" column="password" length="255">
</entity>
</doctrine-mapping>


PHP
use DoctrineORMMappingClassMetadataInfo;

$metadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_NONE);
$metadata->setPrimaryTable(array(
'name' => 'users',
));
$metadata->mapField(array(
'fieldName' => 'id',
'type' => 'integer',
'id' => true,
'columnName' => 'id',
));
'fieldName' => 'username',
'type' => 'string',
'length' => '255',
'columnName' => 'username',
));
'fieldName' => 'password',
'type' => 'string',
'length' => '255',
'columnName' => 'password',
));
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);


Transparent Persistence


$user = new User();

$em->persist($user);
$em->flush();


Single Flush Operation
• Batch inserts
• Best to build up all object changes in your
application and ﬂush no more than 1 or 2 times

• All managed objects are tracked and changesets
generated on ﬂush and used to persist to
RDBMS, MongoDB, etc.


$user = $em->getRepository('User')
->findBy(array('username' => 'jwage'));

$user->setPassword('newpassword');

// Issues SQL update setting the new password
$em->flush();


Why Transparency?
• Better performance
• Easier to cache regular PHP objects that are
not bound to the persistence layer

• Easier to test your domain, no mocking
required

• Ultimate ﬂexibility over the complexity of your
domain entities without being imposed on by
your persistence layer

Performance
• Less abstraction on domain entities improves
performance when working with them.

• Physical accessors and getters are faster.
• Lighter and no required dependencies.


PHP 5.3


PHP 5.3 is Fast


Doctrine1
Doctrine1 beneﬁts from using PHP 5.3. Test suite uses
30% less memory and runs 20% faster


Doctrine2 Performance

Doctrine 1.1
4.3 seconds for 5000 records

Doctrine 2.0

Doctrine 2.0


Uses Namespaces


Namespaces
namespace DoctrineORM;

use DoctrineORMQueryExpr,
DoctrineCommonDoctrineException;

/**
* This class is responsible for building DQL query strings via an object oriented
* PHP interface.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org
* @since 2.0
* @version $Revision$
* @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Jonathan Wage <jonwage@gmail.com>
* @author Roman Borschel <roman@code-factory.org>
*/
class QueryBuilder
{
// ...


Using Namespaces

use DoctrineORMQueryBuilder;

$qb = new QueryBuilder($em);
$qb->select('u')
->from('ModelsUser', 'u')
->orderBy('u.username', 'ASC');

$q = $qb->getQuery();
$users = $q->execute();


Follow PHP 5.3
Interoperability
Standards
http://groups.google.com/group/php-standards


Beneﬁts
• PHP libraries will be able to be mixed without
autoloader issues and conﬂict.

• Symfony2 + Doctrine2 + ZendFramework2
• Load classes from 3 different libraries with one
autoloader and one include path


Doctrine code is
divided into a few
different packages


DoctrineCommon
• Common functionality shared across packages
• Events
• Annotations Library
• Lexer Parser that is used for parsing the
Doctrine Query Language (DQL)

• Other various convenience tools

DoctrineDBAL

• Relational database abstraction layer
• MySQL
• Sqlite
• PostgreSQL
• Oracle
• MsSQL


DBAL is Standalone
Use the DBAL without the ORM


DBAL History
• The Doctrine DBAL is a very powerful
project in itself

• Based off of code forked from other
projects

• PEAR MDB2
• Zend_Db


DBAL
• Using the Doctrine DBAL standalone is a good
option for your PHP projects if a fully featured
ORM is not needed

• API for performing DDL statements, executing
queries, etc.


DBAL Example

$params = array(
'driver' => 'pdo_mysql',
'host' => 'localhost',
'user' => 'root',
'password' => '',
'dbname' => 'doctrine2dbal'
);
$conn = DoctrineDBALDriverManager::getConnection($params);

Execute queries against your database using $conn. The
API is very similar to that of PDO and adds some extra
conveniences.


Schema Manager
$sm = $conn->getSchemaManager();


Schema Manager
• Issue DDL statements through intuitive
API: createTable(), dropTable(),
createForeignKey(), etc.

• Introspect your database schema as well:
listTables(), listTableColumns(), listUsers(),
etc.


Drop and Create Table
$columns = array(
'id' => array(
'type' => Type::getType('integer'),
'autoincrement' => true,
'primary' => true,
'notnull' => true
),
'name' => array(
'type' => Type::getType('string'),
'length' => 255
),
);

$sm->dropAndCreateTable('user', $columns);


Create Foreign Key
$definition = array(
'name' => 'user_id_fk',
'local' => 'user_id',
'foreign' => 'id',
'foreignTable' => 'user'
);
$sm->createForeignKey('profile', $definition);


DoctrineORM

• Object Relational Mapper
• Built on top of the DBAL
• Provides transparent domain object persistence
to relational databases


Persisting to Other
Databases


DoctrineODMMongoDB
Doctrine Object Document Mapper (ODM) for
MongoDB


DoctrineODMMongoDB

• Provides transparent domain object persistence
to MongoDB
• Same architecture and design as the ORM

• New addition to the Doctrine project
• Umbrella of project widened to offer Doctrine
style persistence layers for other popular open
source databases.


Architecture
The architecture of the Doctrine object persistence
layers


The ObjectManager
EntityManager and DocumentManager


API
Simple API for managing the persistent state of objects


Object States
• A NEW object instance has no persistent identity, and is not yet
associated with a ObjectManager (i.e. those just created with the "new"
operator).

• A MANAGED object instance is an instance with a persistent identity
that is associated with an ObjectManager and whose persistence is thus
managed.

• A DETACHED object instance is an instance with a persistent
identity that is not (or no longer) associated with an ObjectManager.

• A REMOVED object instance is an instance with a persistent identity,
associated with an ObjectManager, that will be removed from the
database upon transaction commit.


Creating EntityManager
$config = new DoctrineORMConfiguration();
$config->setMetadataCacheImpl(new DoctrineCommonCacheArrayCache);
$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
$config->setMetadataDriverImpl($driverImpl);

$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

$connectionOptions = array(
'driver' => 'pdo_sqlite',
'path' => 'database.sqlite'
);

$em = DoctrineORMEntityManager::create($connectionOptions, $config);


Creating DocumentManager

$config = new DoctrineODMMongoDBConfiguration();
$config->setMetadataCacheImpl(new DoctrineCommonCacheArrayCache);
$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Documents"));
$config->setMetadataDriverImpl($driverImpl);

$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

$mongo = new DoctrineODMMongoDBMongo();

$dm = DoctrineORMDocumentManager::create($mongo, $config);


Managing the State


Persisting
$user = new User();

// Persist the new object so it is
// saved to the database
$em->flush();


Updating

->find(array('username' => 'jwage'));

// modify the already managed object
$user->setPassword('changed');
$em->flush(); // issues update


Removing


// schedule for deletion
$em->remove($user);
$em->flush(); // issues delete


Detaching

$user->setUsername('changed');

// detach the object
$em->detach($user);

$em->flush(); // does nothing


Doctrine Query Language
The killer ORM feature


Propietary Object
Query Language


Parsed by Recursive
Descent Parser


Constructs AST


AST = Abstract Syntax Tree


Tree representation of the
syntactical structure of a
source language


PHP class names of DQL
parser directly represent
the language itself
• OrderByClause.php
• SelectClause.php
• SelectExpression.php
• Subselect.php
• DeleteClause.php

• Easy to use
• Easy to expand and add new features
• Easy to use and understand the
parsing of a DQL string

• Expand the DQL parser with your
own functionality and add to the
DQL language

Parsing of DQL is Cached
In a production environment a DQL query is only ever
parsed and transformed to SQL once so performance
is not an issue.


Sample DQL Query

$query = $em->createQuery(
'SELECT u, g, FROM User u ' .
'LEFT JOIN u.Groups g ' .
'ORDER BY u.name ASC, g.name ASC'
);
$users = $query->execute();


QueryBuilder API

$qb = $em->createQueryBuilder()
->select('u, g')
->from('User', 'u')
->leftJoin('u.Groups', 'g')
->orderBy('u.name', 'ASC')
->addOrderBy('g.name', 'ASC');

$query = $qb->getQuery();


Executing Queries


foreach ($users as $user) {
// ...
foreach ($user->getGroups() as $group) {
// ...
}
}


Result Cache
$query = $em->createQuery('SELECT u FROM ModelsUser u');
$query->useResultCache(true, 3600, 'user_query');

Execute query again and the results are retrieved from the cache



Symfony2 Integration
The Doctrine features are tightly integrated with
Symfony2


Enabling the DBAL
Enable the DBAL in your application conﬁguration

# config/config.yml

doctrine.dbal:
driver: PDOMySql
dbname: Symfony2
user: root
password: null


Using the DBAL
Use the DBAL connection in your controllers

class UserController extends Controller
{
public function indexAction()
{
$conn = $this->container->getService('database_connection');

$users = $conn->fetchAll('SELECT * FROM users');
}
}


Enabling the ORM
Enable the ORM in your application conﬁguration

# config/config.yml

doctrine.orm: ~


Creating an Entity
Application/HelloBundle/Entity/User.php

namespace ApplicationHelloBundleEntity;

/**
* @Entity
*/
class User
{
/** @Id */
public $id;

/** @Column(type="string", length="255") */
public $username;

/** @Column(type="string", length="255") */
public $password;
}


Create database schema

$ php hello/console doctrine:schema:create


Using the ORM
Use the ORM EntityManager in your controllers

use ApplicationHelloBundleEntitiesUser;

class UserController extends Controller
{
public function createAction()
{
$user = new User();
$user->setName('Jonathan H. Wage');

$em = $this->container->getService('doctrine.orm.entity_manager');
$em->flush();

// ...
}
}


Conclusion
Why use an ORM?


Encapsulation
Encapsulate all your domain logic in one place, in an
object oriented way


Maintainability
The organization of the domain logic in an OO way
improves maintainability


Testability
Keeping a clean OO domain model makes your
business logic easily testable for improved stability


Portability
Write portable and thin application controller code and
fat models.


Questions?
Jonathan H. Wage
jonwage@gmail.com
http://www.twitter.com/jwage
+1 615 513 9185

sensiolabs.com | doctrine-project.org | jwage.com

You can contact Jonathan about Doctrine and Open-Source or for
training, consulting, application development, or business related
questions at jonathan.wage@sensio.com


Libertyvasion2010

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Libertyvasion2010

Semelhante a Libertyvasion2010 (20)

Mais de Jonathan Wage

Mais de Jonathan Wage (20)

Libertyvasion2010