O documento descreve a formação acadêmica e certificações de Ari Stopassola Junior, especializada em tecnologias de informação e análise de sistemas, juntamente com uma visão técnica sobre mapeamento objeto-relacional (ORM) e suas ferramentas, como Doctrine e Eloquent. Aborda conceitos como abstração de banco de dados, tipos de dados, relações entre entidades, e fornece exemplos de código práticos. Também menciona vantagens, desvantagens e outras boas práticas para desenvolvimento com ORM.

2. Bacharel em Informática com ênfase em Análise de
Sistemas pela Unisinos, cursou mestrado em Engenharia
Informática e de Computadores pelo Instituto Superior
Técnico da Universidade Técnica de Lisboa (Portugal),
perito judicial ad hoc especializado em TI (mantenedor do
site PERITO.inf.br), Zend Certified Engineer (PHP 5.3), Zend
Certified PHP Engineer (PHP 5.5) e Zend Framework 2
Certified Architect (ZFCA) #ZEND004019, Certified
ScrumMaster pela Scrum Alliance #203613, Microsoft
Certified Professional (MCP), idealizador do projeto
Certificamp, consultor web e PHP evangelist.
Ari Stopassola Junior

3. Dummy
≠
Dumb

4. Mapeamento Objeto Relacional (ORM)
• Persistir o objeto numa estrutura
de dados relacional
• Tradução para tabelas, campos,
linhas e relacionamentos
• Conversões de tipo
• ORM mascara detalhes obscuros
• Overhead
• Requer aprendizagem de outras
tencnologias. Ex.: DQL (Doctrine),
Propel, Eloquent etc.
http://www.edzynda.com/use-laravels-eloquent-orm-outside-of-laravel/

6. Fontes: https://en.wikipedia.org/wiki/Object-relational_impedance_mismatch
http://blogs.tedneward.com/post/the-vietnam-of-computer-science
impedance mismatch

7. Ferramentas de Object-relational mapping

8. https://github.com/guilhermeblanco

9. Doctrine
Vantagens
• Estabilidade
• Comunidade
• Integração com os
principais frameworks
Desvantagens
•Curva de aprendizado
•Performance

10. Roadmap
• Modelo de domínio
• Database Abstraction Layer (DBAL)
• Object Relational Mapping (ORM)
• Entities
• Entity manager
• Mapping
• Repositories
• Life cicle events
• Query Builder
• Caching
• Proxies
• Event subsystem

11. Passeios
Nome
Descrição
Preço
Distância
...
Objetos Base relacional
Nome Descrição Preço Distância
Classe Passeios Tabela Passeios
ORM

12. composer require doctrine/orm

13. Fonte: http://docs.doctrine-project.org/projects/doctrine1/en/latest/en/manual/introduction.html

14. PDO x DBAL
Data-access Layer
• Permite a troca de banco de
dados utlizando as mesmas
chamadas de métodos
• Não reescreve SQL
• Tão pouco emula
funcionalidades inexistentes
Database Abstraction Layer
• Agnóstico
• Manipulação por meio de uma
API Orientada à Objetos
• Traz maior consistência na
manipulação do BD
• Doctrine usa DBAL, mas você
pode usar DBAL sem Doctrine
• DBAL utiliza PDO internamente

15. ExemplodeDBAL
<?php
include __DIR__ . '/doctrine_autoloader.php';
use DoctrineDBALConfiguration;
use DoctrineDBALDriverManager;
//Obtém a conexão
$dbParams = include __DIR__ . '/database.params.php';
$conn = DriverManager::getConnection($dbParams, new Configuration());
$sql = "SELECT * FROM orcamentos WHERE sobrenome = ?";
$stmt = $conn->prepare($sql);
$stmt->execute(array('STOPASSOLA'));
//OU utilizando QueryBuilder
$qb = $conn->createQueryBuilder();
$qb->select('*')->from('orcamentos')->where('sobrenome = :name');
$data = array(':name' => 'STOPASSOLA');
while ($tupla = $stmt->fetch()) {
var_dump($tupla);
}

16. Mapeandos os tipos de dados
Tipos do Doctrine Tipos SQL Tipos PHP
string VARCHAR string
integer INT integer
smallint SMALLINT integer
bigint BIGINT string
boolean BOOLEAN boolean
decimal DECIMAL double
date DATETIME DateTime
time TIME DateTime
datetime DATETIME/TIMESTAMP DateTime
text CLOB string

17. Eloquent implementa Active Record
class Passeios extends Eloquent {
}
$passeio = Passeios::find(32);
$passeio->name = "Tour Uva e Vinho";
$passeio->save();
Fonte: http://www.martinfowler.com/eaaCatalog/activeRecord.html

18. Doctrine 2 implementa Data Mapper
Fonte: http://martinfowler.com/eaaCatalog/dataMapper.html

19. <?php
/**
* @Entity
* @Table(name="passeios")
*/
class Passeio
{
/**
* @Id
* @GeneratedValue(strategy="AUTO")
* @Column(type="integer")
*/
private $id;
/**
* @Column(type="string", length=255, nullable=true)
*/
private $nome;
}

21. Annotations
• Instruções declarativas dentro de blocos de documentação
• Doctrine usa anotações para definir o mapeamento objeto-
relacional
• Annotations são metadados que descrevem a entidade, como ela
deve ser armazenada, que tipo de colunas serão usadas etc.
• Inspirado no PHPDocumentor www.phpdoc.org
• Definida sempre acima do nome da classe e de cada atributo
• Entre /** xxx */ e começam com o simbolo @
/**
* Produto
*
* @Entity
* @Table(name="produtos")
*/

22. Anotações obrigatórias
"Learning Doctrine" by Doug Bierer (O'Reilly)

23. @ORMColumn(Type="xxxx")
• smallint, integer, bigint
• decimal, float
• string, text, guid
• binary, blob, boolean
• date, date time, datetimez, time
• array, simple_array, json_array, object
http://doctrine-
dbal.readthedocs.io/en/latest/reference/types.html

24. Schema
Laravel ➡ Migrations
public function up()
{
Schema::create('passeios', function(Blueprint $table)
{
$table->increments('id');
$table->string('nome');
$table->text('descricao');
$table->timestamps();
});
}
$ php artisan migrate
$ php artisan make:migration create_passeios_table --create="passeios"

25. Entity Manager
$passeio = new Passeio;
$passeio->setName("Tour Itaimbezinho");
EntityManager::persist($passeio);
EntityManager::flush();

26. Entity Manager
$passeio = new Passeio;
$passeio->setName("Tour Itaimbezinho");
EntityManager::persist($passeio);
EntityManager::flush();

27. Fotohttps://www.flickr.com/photos/pragdave/173640462

28. Unit of Work
Fonte: http://martinfowler.com/eaaCatalog/unitOfWork.html
• Estratégia transactional write-behind
• Retarda a execução de cláusulas
SQL para executá-las
posteriormente de forma mais
eficiente
• Executa numa ordem tal de modo a
liberar o mais rápido possível as
tabelas em questão (write locks), ao
fim da transação

29. Doctrine Query Language – DQL
$query = EntityManager::createQuery("select p from
VendaBalcaoEntitiesPasseios p where p.preco >= 90
AND p.preco <= 150");
$passeios = $query->getResult();

30. Lab: https://github.com/stopassola/doctrine_lab

31. Herança: estratégia Single Table
/**
* @Entity
* @InheritanceType("SINGLE_TABLE")
* @DiscriminatorColumn(name="discr", type="string")
* @DiscriminatorMap({"person"="Usuario","employee"="Colaborador"})
*/
Revistaphp|architect,ediçãomarço/2016.

32. Herança: estratégia Class Table
/**
* @Entity
* @InheritanceType("TABLE_PER_CLASS")
* @DiscriminatorColumn(name="discr", type="string")
* @DiscriminatorMap({"person"="Usuario","employee"="Colaborador"})
*/
Revistaphp|architect,ediçãomarço/2016.

33. Hidratação
$produto = $entityManager->find('Produto', 5);

34. Possível workflow
1) Crie as entidades com suas respectivas annotations
2) Verifique incoerências das classes mediante o BD:
$ vendor/bin/doctrine orm:validate-schema
3) Realize a varredura nas annotations e crie as respectivas tabelas:
$ vendor/bin/doctrine orm:schema-tool:update --force

35. Relação 1:1 (lê-se um-para-um)
“cada colaborador trabalha para uma empresa parceira”
Colaborador
$id
$parceiro
Parceiro
$id
Owning side Inverse side
/**
* @OneToOne(targetEntity="Parceiro")
* @JoinColumn(name="parceiro", referencedColumnName="id")
*/
protected $parceiro;

36. Hóspede
$id
$nome
Hóspede
$id
$nome
Hotel
$id
$hospedes[]
Hóspede
$id
$hotel
Owning side Inverse side
/**
* @var DoctrineCommonCollectionsCollection
* @OneToMany(targetEntity="Hospede", mappedBy="hotel")
*/
protected $hospedes;
Relação 1:N (um-para-ene)
“Um hotel hospeda vários hóspedes”

37. id nome preco duracao
1 Tour Uva e Vinho 99 12
2 Noite Gaúcha 110 4
3 Alpen Park 30 3
4 Canyon Itaimbezinho 99 10
5 Parques de Gramado 35 5
pacotes_id passeios_id
1 1
1 2
2 3
2 4
3 3
4 1
4 5
Passeios
Relação N:M (ene-para-eme)
“Pacotes têm passeios e o mesmo passeio compõe vários pacotes”
id nome
1 Serra Gaúcha Tradicional
2 Aventura
3 Serra com as Crianças
4 Italiana e Alemã
Pacotes

38. Pacote
$id
$passeios[]
Pacote
$id
$passeios[]
Hóspede
$id
$nome
Hóspede
$id
$nome
Pacote
$id
$passeios[]
Passeio
$id
$pacotes[]
Owning side Inverse side
/**
* @ManyToMany(targetEntity="Passeio", mappedBy="pacotes")
* @JoinTable(name="pacotes_has_passeios",
* joinColumns={@JoinColumn(name="pacotes_id", "id")},
* inverseJoinColumns={@JoinColumn(name="passeios_id", "id")})
*/
protected $passeios;
Relação N:M (ene-para-eme)
“Pacotes têm passeios e o mesmo passeio compõe vários pacotes”

39. Referências

40. E-mail:
arijunior@gmail.com
Twitter: @stopassola
Skype: stopassola
LinkedIn:
http://pt.linkedin.com/in/stopassola
Facebook:
http://www.facebook.com/arijunior
Sites:
http://slideshare.net/arijunior
http://www.perito.inf.br
http://www.certificamp.com
http://www.rumoacertificacaophp.com
Contatos