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

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

questions at jonathan.wage@sensio.com

Jonathan H. Wage

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

• http://www.jwage.com

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

• 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

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

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

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

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 <guilhermeblanco@hotmail.com> * @author Jonathan Wage <jonwage@gmail.com> * @author Roman Borschel <roman@code-factory.org> */class QueryBuilder{ // ...

Namespaces

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

• 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

• 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

• 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 jonathan.wage@sensio.com

Jonathan H. Wagejonwage@gmail.comhttp://www.twitter.com/jwage+1 615 513 9185

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

Questions?

Libertyvasion2010

Documents

Transcript of Libertyvasion2010

The Dutch Republic In International Trade

Keyboard Shortcuts for the Opera Browser for Mac OS X

How Computer Monitors Work

Star Wars Prequel Trilogy Trivia (Episodes I-III)

I Am a Holocaust Denier and I Am Unafraid

Do you admire Leonardo da Vinci?

xCDC14a

Effective Parenting: Establishing Boundaries

Who Killed God

The Best American Humorous Short Stories

The Last Carnival I Ever Saw

Compressing And Decompressing Folders

Chapter 24

Personality Development

Barclays1

Tragic Heroes

Introduction to Six Sigma

(Tesla) - The Tesla Magnetic Car Engine

United States Constitution

Simple Functions in Haskell