libertyvasion2010

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

Doctrine 2.0Enterprise Object Relational Mapper for PHP 5.3


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

http://www.symfony-project.org





You can contact Jonathan about Doctrine and Open-Source or for training, consulting, application development, or business related

questions at [email protected]

Jonathan H. Wage

• http://www.twitter.com/jwage

• http://www.jwage.com

• http://www.facebook.com/jwage





mailto:[email protected]


http://www.twitter.com/jwage

http://www.twitter.com/jwage

http://www.jwage.com







• First commit April 13th 2006

• First stable version finished and Released September 1st 2008

• One of the first 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.

Project History





• Roman S. Borschel

• Guilherme Blanco

• Benjamin Eberlei

• Bulat Shakirzyanov

• Jonathan H. Wage


The Team






Object Relational MapperWhat 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






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

The Doctrine1 Way






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 WayHow 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 InformationSpecify your mapping information with XML, YAML or

DocBlock Annotations


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

YAML






<?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>

XML





http://doctrine-project.org/schemas/orm/doctrine-mapping




http://www.w3.org/2001/XMLSchema-instance

http://www.w3.org/2001/XMLSchema-instance

http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd





use Doctrine\ORM\Mapping\ClassMetadataInfo;

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

PHP






Transparent Persistence






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

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






Single Flush Operation

• Batch inserts

• Best to build up all object changes in your application and flush no more than 1 or 2 times

• All managed objects are tracked and changesets generated on flush 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 flexibility 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






Doctrine1Doctrine1 benefits from using PHP 5.3. Test suite uses

30% less memory and runs 20% faster


Doctrine 1.14.3 seconds for 5000 records



Doctrine2 Performance






Uses Namespaces






namespace Doctrine\ORM;

use Doctrine\ORM\Query\Expr, Doctrine\Common\DoctrineException;

/** * 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 <[email protected]> * @author Jonathan Wage <[email protected]> * @author Roman Borschel <[email protected]> */class QueryBuilder{ // ...

Namespaces





http://www.opensource.org/licenses/lgpl-license.php

http://www.opensource.org/licenses/lgpl-license.php

http://www.doctrine-project.org

http://www.doctrine-project.org








use Doctrine\ORM\QueryBuilder;

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

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

Using Namespaces






http://groups.google.com/group/php-standards

Follow PHP 5.3 Interoperability

Standards





http://groups.google.com/group/p%5B

http://groups.google.com/group/p%5B


• PHP libraries will be able to be mixed without autoloader issues and conflict.

• Symfony2 + Doctrine2 + ZendFramework2

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

Benefits






Doctrine code is divided into a few different packages






Doctrine\Common• Common functionality shared across packages

• Events

• Annotations Library

• Lexer Parser that is used for parsing the Doctrine Query Language (DQL)

• Other various convenience tools






Doctrine\DBAL

• Relational database abstraction layer

• MySQL• Sqlite• PostgreSQL• Oracle• MsSQL






DBAL is StandaloneUse the DBAL without the ORM


• The Doctrine DBAL is a very powerful project in itself

• Based off of code forked from other projects

• PEAR MDB2

• Zend_Db

DBAL History






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 = \Doctrine\DBAL\DriverManager::getConnection($params);

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

conveniences.






$sm = $conn->getSchemaManager();

Schema Manager






Schema Manager

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

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






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

Drop and Create Table






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

Create Foreign Key






Doctrine\ORM

• Object Relational Mapper

• Built on top of the DBAL• Provides transparent domain object persistence

to relational databases






Persisting to Other Databases






Doctrine\ODM\MongoDBDoctrine Object Document Mapper (ODM) for

MongoDB


Doctrine\ODM\MongoDB

• 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.






ArchitectureThe architecture of the Doctrine object persistence

layers


The ObjectManagerEntityManager and DocumentManager


APISimple API for managing the persistent state of objects

• 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.


Object States






$config = new \Doctrine\ORM\Configuration();$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache);$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 = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

Creating EntityManager






$config = new \Doctrine\ODM\MongoDB\Configuration();$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache);$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Documents"));$config->setMetadataDriverImpl($driverImpl);

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

$mongo = new \Doctrine\ODM\MongoDB\Mongo();

$dm = \Doctrine\ORM\DocumentManager::create($mongo, $config);

Creating DocumentManager






Managing the State






Persisting

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

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






Updating

$user = $em->getRepository('User') ->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 LanguageThe 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 CachedIn a production environment a DQL query is only ever parsed and transformed to SQL once so performance

is not an issue.


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

Sample DQL Query






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

$users = $query->execute();

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






Result Cache

$query = $em->createQuery('SELECT u FROM Models\User u');$query->useResultCache(true, 3600, 'user_query');$users = $query->execute();

$users = $query->execute();

Execute query again and the results are retrieved from the cache






Symfony2 IntegrationThe Doctrine features are tightly integrated with

Symfony2


Enabling the DBAL

# config/config.yml

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

Enable the DBAL in your application configuration






Using the DBAL

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

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

Use the DBAL connection in your controllers






Enabling the ORM

# config/config.yml

doctrine.orm: ~

Enable the ORM in your application configuration






namespace Application\HelloBundle\Entity;

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

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

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

Application/HelloBundle/Entity/User.php

Creating an Entity






$ php hello/console doctrine:schema:create

Create database schema






Using the ORM

use Application\HelloBundle\Entities\User;

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

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

// ... }}

Use the ORM EntityManager in your controllers






ConclusionWhy use an ORM?


EncapsulationEncapsulate all your domain logic in one place, in an

object oriented way


MaintainabilityThe organization of the domain logic in an OO way

improves maintainability


TestabilityKeeping a clean OO domain model makes your

business logic easily testable for improved stability


PortabilityWrite portable and thin application controller code and

fat models.


You can contact Jonathan about Doctrine and Open-Source or for training, consulting, application development, or business related

questions at [email protected]

Jonathan H. [email protected]://www.twitter.com/jwage+1 615 513 9185

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

Questions?









libertyvasion2010

Documents

new user

class user

integer id

auto username

domain model

mapping orm

objectrelational mapping

new password