Doctrine 2: Enterprise Persistence Layer for PHP

Doctrine 2: Enterprise Persistence Layer for PHP 5.3 www.doctrine-project.org www.sensiolabs.com

Doctrine 2
Enterprise Persistence Layer for PHP 5.3

Big Lamp Camp 2009 #eLAMP


Jonathan H. Wage
• Web developer for a decade
• Open Source Evangelist
• Published Author
• Contributes to...
• ...Doctrine
• ...Symfony
• ...and more
• Employee of Sensio Labs, the creators of
Symfony


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



How many have used Doctrine?
• Before 1.0?
• 1.0?
• 1.1?
• 1.2?
• 2.0?



Doctrine 1.0
• First commit April 13th 2006

• Finished and Released September 1st 2008

• One of the ﬁrst true ORM implementation for PHP

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

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


Doctrine 1.1
• Continued evolution of 1.0

• Dozens of small improvements

• Several signiﬁcant new features

• Too many bug ﬁxes to count



Doctrine 1.2
• Last LTS release of the Doctrine 1.x series

• More bug ﬁxes

• More improvements

• Even more new features

• Scheduled to release this month



Doctrine 2.0



Requires PHP 5.3



Three Main Packages



Common



DBAL



ORM



Fully implements namespaces



Namespaced Code
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();



Follows PHP 5.3 technical
interoperability standards

http://groups.google.com/group/php-standards/web/php-coding-standard-version-2



What does this mean?
• PHP libraries will ﬁnally be 100% technically interoperable
and have optimum autoloading performance

• Symfony 2.0 + Doctrine 2.0 + Zend Framework 2.0

• Load classes from 3 different libraries with one
autoloader and one include path

• Share SplClassLoader implementation: http://
gist.github.com/221634

• Implement SplClassLoader in C/PHP :)



Performance of PHP 5.3



Doctrine 1 and 2 get signiﬁcant
performance increase from 5.3



30% Less Memory Used



20% Faster



What’s my point?

USE PHP 5.3!



Let the numbers talk

Doctrine 1.1
4.3 seconds for 5000 records

Doctrine 2.0

Doctrine 2.0



Doctrine 2 is FAST!



The code isn’t that bad on the
eyes either



Quit imposing on my
domain model!!



The Doctrine 1 Way

class User extends Doctrine_Record
{
public function setTableDefinition()
{
$this->hasColumn('id', 'integer', null, array(
'primary' => true,
'auto_increment' => true
));

$this->hasColumn('username', 'string', 255);
}
}



What is the problem?
• We have to extend Doctrine_Record

• It imposes methods, properties, and other
junk on our domain model objects

• We have to instantiate a dummy User in
order to instantiate the metadata for the
model

• Slow, ugly and just not pretty :)


The new Doctrine 2 Way
Specify mapping information with doc block
annotations, yaml, xml, or raw PHP code.



With Annotations
/**
* @Entity
* @Table(name="user")
*/
class User
{
/**
* @Id
* @Column(type="integer")
* @GeneratedValue(strategy="auto")
*/
public $id;

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



With YAML

EntitiesUser:
type: entity
table: users
fields:
id:
type: integer
id: true
generator:
strategy: AUTO
name:
type: string(50)



With 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="EntitiesUser" table="users">
<field name="name" type="string" column="name" length="50" precision="0" scale="0">
<options/>
</field>
<id name="id" type="integer" column="id">
<generator strategy="AUTO"/>
</id>
</entity>
</doctrine-mapping>



With 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',
));
$metadata->mapField(array(
'fieldName' => 'name',
'type' => 'string',
'length' => '50',
'columnName' => 'name',
));
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);



No more base class...
$user = new EntitiesUser();
$user->setUsername('jwage');
print_r($user);

User Object
(
[id] =>
[username] => jwage
)

...means a clean domain model


Doctrine 2 is heavily decoupled
so you can use things standalone



Use the DBAL without the ORM!



Database Abstraction Layer
• The Doctrine DBAL is a very powerful
project in itself

• Based off of code borrowed from other
projects

• PEAR MDB2

• Zend_Db



Database Abstraction Layer
• 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.

• Connect to different types of databases:
mysql, sqlite, pgsql, oracle, etc.



DBAL Examples



Create a Connection to MySQL

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



Get the 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 a 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 a Foreign Key

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



So much more...
• Fully featured DBAL for manipulating your
database with DDL statements

• Introspect your database and learn about it

• Execute queries and retrieve data

• Support for transactions



The ORM Key Feature



Doctrine Query
Language



DQL stands for Doctrine Query
Language and is heavily
influenced by HQL from Hibernate



Proprietary OQL(object
query language) dialect



The DQL is parsed by a
hand written recursive
descent parser



Constructs AST



AST = Abstract Syntax Tree



Tree representation of the
syntactic 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
etc. etc.



Every DQL feature has a
class to handle the parsing



• 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



DQL parser is very fast as it is.
With final SQL caching it
becomes invisible.



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();



Using the QueryBuilder

$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) {
// ...
}
}



Working with Entities



The EntityManager



The EntityManager is
responsible for managing
the persistence of entities



Creating the EntityManager

$config = new DoctrineORMConfiguration();
$config->setMetadataCacheImpl(new DoctrineCommonCacheArrayCache);
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

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

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



Persisting Entities
$user = new User;
$user->setUsername('jwage');
$user->setPassword('changeme');

$profile = new Profile;
$profile->setName('Jonathan H. Wage');

$user->setProfile($user);

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

$em->flush();



Deleting Entities

$user1 = $em->find('User', 1);
$user2 = $em->find('User', 2);

$em->remove($user1);
$em->remove($user2);
$em->flush();



EntityManager::ﬂush()
• Commits any changes to the managed
entities

• Efficiently executes insert, update and
delete statements

• Keep number of ﬂush() operations down to
about 1-2 times per request



The EntityManager::ﬂush()
operation is able to insert,
update and delete entities very
efficiently. It is ideal to keep
your ﬂush operations to about
1-2 times per request



Metadata Cache

$config = new DoctrineORMConfiguration();
$config->setMetadataCacheImpl(new DoctrineCommonCacheApcCache);



In production cache the
ClassMetadata instances
populated by the parsed
annotations, yaml, xml, etc.



Query Cache

$config->setQueryCacheImpl(new DoctrineCommonCacheApcCache);



In production cache the parsing
of a DQL query and the ﬁnal SQL
generated.



Result Cache

$config->setResultCacheImpl(new DoctrineCommonCacheApcCache);



In production cache the hydrated
data of your queries to avoid
unnecessary queries to the
database.



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

Execute it again and it pulls the results from
the cache instead of hitting the database




Using Result Cache The parsing of this
query will only ever happen
once with the query cache
configured.

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

Execute it again and it pulls the results from
the cache instead of hitting the database




Inheritance Mapping



Mapped Superclasses



/** @MappedSuperclass */
abstract class MappedSuperclassBase
{
/** @Column(type="integer") */
private $mapped1;

/** @Column(type="string") */
private $mapped2;

/**
* @OneToOne(targetEntity="MappedSuperclassRelated1")
* @JoinColumn(name="related1_id", referencedColumnName="id")
*/
private $mappedRelated1;

// ... more fields and methods
}



Extend the Superclass



/** @Entity */
class EntitySubClass extends MappedSuperclassBase
{
/** @Id @Column(type="integer") */
private $id;
/** @Column(type="string") */
private $name;

// ... more fields and methods
}



Single Table Inheritance



/**
* @Entity
* @InheritanceType("SINGLE_TABLE")
* @DiscriminatorColumn(name="discriminator", type="string")
* @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
*/
class Person
{
// ...
}

/**
* @Entity
*/
class Employee extends Person
{
// ...
}



Single Table
• All classes of a hierarchy are mapped to a
single table

• Discriminator column used to distinguish
type of a row in the database

• Efficient for querying across all types in the
hierarchy or for speciﬁc types.

• Queries limited by type discriminator


Class Table Inheritance



/**
* @Entity
* @InheritanceType("JOINED")
* @DiscriminatorColumn(name="discr", type="string")
* @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
*/
class Person
{
// ...
}

/** @Entity */
class Employee extends Person
{
// ...
}



Class Table
• Each class in a hierarchy is mapped to
several tables

• Table of a child class is linked to the table
of a parent class

• Discriminator column used to distinguish
type of a row in the database

• Queries almost always require joins


Testing



PHPUnit for Unit Testing



bambino:tests jwage$ phpunit Doctrine/Tests/AllTests.php
PHPUnit 3.3.17 by Sebastian Bergmann.

...............................................S.SS......... 60 / 673
............................................................ 120 / 673
............................................................ 180 / 673
...SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS.................... 240 / 673
............................................................ 300 / 673
............................................................ 360 / 673
............................................................ 420 / 673
............................................................ 480 / 673
............................................................ 540 / 673
............................................................ 600 / 673
.................SSSS.....................SS.S......S..SS.S. 660 / 673
.....S..SS.S.

Time: 3 seconds

OK, but incomplete or skipped tests!
Tests: 673, Assertions: 1771, Skipped: 55.



Sismo for Continuous Integration



Growl Notiﬁcations



Sismo keeps a close eye on all of our
projects. We even run the Doctrine 2 tests
against multiple supported databases.



Custom Types



namespace DoctrineDBALTypes;

class MyCustomObjectType extends Type
{
public function getName()
{
return 'MyCustomObjectType';
}

public function getSqlDeclaration(array $fieldDeclaration,
DoctrineDBALPlatformsAbstractPlatform $platform)
{
return $platform->getClobDeclarationSql($fieldDeclaration);
}

public function convertToDatabaseValue($value,
DoctrineDBALPlatformsAbstractPlatform $platform)
{
return serialize($value);
}

public function convertToPHPValue($value)
{
return unserialize($value);
}
}



Type::addCustomType(
'MyCustomObjectType',
'DoctrineDBALTypesMyCustomObjectType'
);



Override Types



class MyString extends StringType
{

}

Type::overrideType('string', 'DoctrineDBALTypesMyString');



Thanks!!



Jonathan H. Wage
jonathan.wage@sensio.com
+1 415 992 5468

sensiolabs.com | doctrine-project.org | sympalphp.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


Doctrine 2: Enterprise Persistence Layer for PHP

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Destacado

Destacado (20)

Similar a Doctrine 2: Enterprise Persistence Layer for PHP

Similar a Doctrine 2: Enterprise Persistence Layer for PHP (20)

Más de Jonathan Wage

Más de Jonathan Wage (19)

Último

Último (20)

Doctrine 2: Enterprise Persistence Layer for PHP