Doctrine 2.0: A evolução da persistência em PHP

Doctrine 2.0: A evolução da persistência em PHP Benjamin Eberlei, Guilherme Blanco, Jonathan Wage & Roman Borschel

Doctrine 2.0
A evolução da persistência em PHP

PHP Conference Brazil 2009 www.doctrine-project.org


Guilherme Blanco
• Desenvolvedor há 10+ anos
• Evangelista de projetos OS
• Trabalhar para Naspers/MIH
• Contribui para...
• ...Doctrine
• ...Zend Framework
• ...Symfony
• ...PHP
• ...etc


Guilherme Blanco

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

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

Versão modificada da apresentada na ZendCon UnCon 2009.
Esta apresentação é a tradução da palestra apresentada por
Jonathan Wage no Big LAMP Camp 2009 em Nashville, TN.



O que estão falando por aí?
• “Quanto mais eu uso Doctrine, mais e mais eu imagino como
consegui viver até hoje sem ele” - @sidhighwind

• “PHP 5.3.1 lançado hoje. Queria que Cpanel integrasse no
EasyApache. Quero namespaces e Doctrine 2!” - @diffkid

• “Fazendo meu primeiro site com Symfony e Doctrine. Mais
fácil que imaginei!” - @timbowler

• “Implementado Doctrine ORM com sucesso no Zend
Framework para meu próximo projeto. Está demais!” -
@otobrglez

• http://twitter.com/#search?q=%23doctrine


Quantos já usaram Doctrine?
• Pre 1.0?
• 1.0?
• 1.1?
• 1.2?
• 2.0?



Doctrine 1.0
• Primeiro commit em 13 de Abril de 2006

• Concluído e lançado em 1 de Setembro de 2008

• Uma das 1as. implementações de ORM para PHP

• Primeiro lançamento LTS (Long Term Support).
Mantido até 1 de Março de 2010

• Integra-se com frameworks populares: Symfony,
Zend Framework, Code Igniter, etc.


Doctrine 1.1
• Evolução continuada da 1.0

• Dezenas de pequenas melhorias

• Novos recursos signiﬁcantes

• Bug ﬁxes? Impossível contabilizar...



Doctrine 1.2
• Último lançamento LTS da versão 1.x

• Mais e mais bug ﬁxes

• Mais melhorias

• Dezenas de novos recursos

• Lançamento em 2 semanas!!!



Doctrine 2.0



Compatível com PHP 5.3.0+



Três principais pacotes



Common



DBAL



ORM



Implementado integralmente usando namespaces



Código em Namespace
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
{



Usando Namespaces

use DoctrineORMQueryBuilder;

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

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



Acompanha os padrões de
interoperabilidade técnica do PHP 5.3
PSR = PHP Standards Recommendation

http://tr.im/psr_0



O que isso signiﬁca?
• Bibliotecas PHP ﬁnalmente serão 100% interoperáveis,
com a melhor performance possível de carga

• Symfony, Doctrine, Zend Framework, PEAR2/Pyrus,
Typo3, Lithium, Flow3, Solar, Agavi, etc.

• Carregue classes de 3 bibliotecas diferentes com um
único autoloader e um único include path

• Compartilhe a implementação da SplClassLoader!
http://gist.github.com/221634

• Interessados em implementar SplClassLoader em C ??? =)


Performance do PHP 5.3



Doctrine 1 e 2 possuem aumento
de performance signiﬁcativos
com o PHP 5.3



-30% Consumo de Memória



+20% Rapidez



Qual é o meu ponto de vista?

USE PHP 5.3!



Números falam por si só

Doctrine 1.1
4.3 s para 5000 registros

Doctrine 2.0

Doctrine 2.0



Doctrine 2 é RÁPIDO!



O código não é tão
ruim aos olhos



Chega de impôr dados no meu
modelo de domínio!!!



O jeito Doctrine 1.X

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

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



Qual é o problema?
• Pfff... Requer extender Doctrine_Record

• Impõe métodos, propriedades e mais lixo
nos nossos objetos de domínio

• Necessário instanciar um objeto “burro”
User para obter metadados do modelo

• LenTU...feIU i sImPLeSMENti xXxATu!!!!! =P



O novo jeito Doctrine 2
Especiﬁque as informações de mapeamento using
doc block Annotations, YAML, XML ou PHP.



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

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



Com YAML

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



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



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



Sem a necessidade de extender a classe Base...

$user = new EntitiesUser();
$user->setUsername('jwage');
print_r($user);

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

...signiﬁca modelo de domínio limpo!



Doctrine 2 é quase integralmente
desacoplado. Você pode utilizar
recursos individualmente



Use a DBAL sem a ORM!



Database Abstraction Layer
• A DBAL é um projeto poderoso por si só

• Baseada em código de outros projetos:

– PEAR MDB2

– Zend_Db



Database Abstraction Layer
• Utilizar a Doctrine DBAL sozinha é uma boa
opção para projetos PHP se uma ORM
completa não é necessária

• API para executar queries, alterações no
schema, etc.

• Conecta-se com diferentes tipos de bases
de dados: mysql, sqlite, pgsql, oracle, etc.



Examplos de uso da DBAL



Criando conexão com o MySQL

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



Obtendo o Schema Manager

$sm = $conn->getSchemaManager();



Schema Manager

• Dispara DDLs através de uma API intuitiva:
– createTable()
– dropTable()
– createForeignKey()

• Introspecção do seu schema:
– listTables()
– listTableColumns()
– listUsers()


Remover e Criar uma Tabela
$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);



Criar uma chave estrangeira

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



E muito mais...
• DBAL cheia de recursos para manipular sua
base com comandos DDL

• Inspecione sua base e aprenda sobre ela

• Execute queries e recupere dados

• Suporte a transações



O recurso chave da ORM



Doctrine Query
Language



DQL significa Doctrine Query
Language e é fortemente
influenciada por HQL do Hibernate



Dialeto OQL (Object
Query Language)
proprietário



A DQL é processada por
um parser LL(*) escrito
manualmente



Constrói AST



AST = Abstract Syntax Tree



Representação na forma de
Árvore de uma estrutura sintática
de um código de uma linguagem



Nomes de classes PHP do DQL parser
representam diretamente a linguagem

OrderByClause.php
SelectClause.php
SelectExpression.php
Subselect.php
DeleteClause.php
etc. etc.



Cada recurso DQL possui uma
classe para manipular seu
processamento



• Fácil de usar

• Fácil de expandir e incluir novos recursos

• Fácil de usar e entender o processamento
de uma consulta DQL

• Expanda o DQL parser com sua própria
funcionalidade e adicione à linguagem DQL



O DQL parser é muito rápido. Com
um cache de SQL gerada fica
praticamente invisível.



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



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



Executando as Queries


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



Trabalhando com Entidades



O EntityManager



O EntityManager é
responsável por gerenciar a
persistência das Entidades



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



Persistindo Entidades
$user = new User;
$user->setUsername('gblanco');
$user->setPassword('changeme');

$profile = new Profile;
$profile->setName('Guilherme Blanco');

$user->setProfile($user);

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

$em->flush();



Removendo Entidades

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

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



EntityManager::flush()
• Executa quaisquer alterações das entidades
gerenciadas

• Executa de forma eficiente comandos de
insert, update e delete (Topological Sorting)

• Mantenha o número de operações flush()
baixo (1-2 vezes por requisição)



Cache de Metadados

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



No ambiente de produção, “cacheie”
as instâncias de ClassMetadata
populadas via processamento de
Annotations, YAML, XML, etc.



Cache de Queries

$config->setQueryCacheImpl(new DoctrineCommonCacheApcCache);



No ambiente de produção,
“cacheie” o processamento da
consulta DQL armazenando a
SQL ﬁnal gerada



Cache de Resultados

$config->setResultCacheImpl(new DoctrineCommonCacheApcCache);



Em ambiente de produção,
“cacheie” os dados populados
prevenindo consultas
desnecessárias à base de dados



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

Execute novamente e os resultados serão
retornados do cache ao invés de acessar a
base novamente



Usando o Cache de Resultados O processamento
desta query só acontece
uma vez com o Cache de
Query

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

Execute novamente e os resultados serão
retornados do cache ao invés de acessar a
base novamente



Mapeando Herança



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
}



Extende a 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
• Todas as classes da hierarquia são mapeadas
para uma única tabela

• Coluna de discriminação usada para distinguir
o tipo da linha na tabela

• Eﬁciente para consultar entre todos os tipos
na hierarquia ou tipos especíﬁcos

• Consultas limitadas pelo tipo de discriminição



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
• Cada classe na hierarquia é mapeada em
diversas tabelas

• Tabela de uma classe ﬁlho é linkada com a
tabela da classe pai

• Coluna de discriminação usada para
distinguir o tipo de linha na tabela

• Consultas quase sempre requerem joins


Testes



PHPUnit para Test Unitário



MacBlanco:tests guilhermeblanco$ phpunit --no-static-backup Doctrine/Tests/AllTests.php
PHPUnit 3.4.1 by Sebastian Bergmann.

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

Time: 5 seconds

OK, but incomplete or skipped tests!
Tests: 696, Assertions: 1847, Skipped: 55.



Sismo para
Continuous Integration



Growl Notiﬁcations



Sismo ﬁca de olho em todos nossos
projetos. Nós também rodamos os testes
do Doctrine 2 em múltiplos banco de
dados suportados.



Tipos Customizados



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::addType(
'MyCustomObjectType',
'DoctrineDBALTypesMyCustomObjectType'
);



Sobrepondo Tipos



class MyString extends StringType
{

}

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



Perguntas???



Guilherme Blanco
guilhermeblanco@php.net
+55 16 9215-8480

Twitter: @guilhermeblanco
MSN: guilhermeblanco@hotmail.com


Doctrine 2.0: A evolução da persistência em PHP

Mais conteúdo relacionado

Semelhante a Doctrine 2.0: A evolução da persistência em PHP

Mais de Guilherme Blanco

Último

Doctrine 2.0: A evolução da persistência em PHP