Doctrine ORM – parte 2

Doctrine ORM

Bom dia pessoal,

Dando sequencia ao post anterior do Doctrine, hoje estarei ensinando a como criar entidades, inserir dados e fazer consultas DQL no Symfony e no Zend Framework.

Então vamos la. Por padrão no Zend Framework, as entidades deverão estar localizadas no diretório “Entity” dentro da pasta src de seu módulo(Ex: module/Application/src/Application/Entity no caso do meu módulo chamar-se “Application”) e no Symfony, dentro do diretório do seu bundle(Ex. src/AppBundle/Entity no caso do meu bundle chamar-se “AppBundle”).

Normalmente, criamos a classe de entidade com o nome desejado para tabela, mas caso deseje você poderá especificar um nome diferente da entidade. Se for de sua preferência, poderá inclusive usar sub-pastas para organizar melhor suas entidades através do namespace.

Criei uma classe chamada “Estado”, representando uma tabela chamada estado. Como sempre, utilizo annotation para definir parâmetros do Doctrine, justamente pelo fato de ser mais fácil e rápido de ser alterado. No meu exemplo, o namespace está apontando para o diretório de minha classe criada no Symfony, o mesmo deverá ser alterado para o namespace de seu framework.

<?php
namespace AppBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

class Estado {

	/**
	  * @var integer Identificador único do registro.
	  *
	  * @ORM\Id
	  * @ORM\Column(type="integer")
	  * @ORM\GeneratedValue(strategy="IDENTITY")
	  */
	private $id;

	/**
	  * @var string Nome do estado.
	  *
	  * @ORM\Column(type="string")
	  */
	private $nome;

	/**
	  * @var string UF relativa ao estado.
	  *
	  * @ORM\Column(type="string", length=2)
	  */
	private $uf;

	/**
	  * @var string ISO 3166-1 alpha-2 do país.
	  *
	  * @ORM\Column(type="string", length=2)
	  */
	private $pais;

}

Nome que as variáveis estão representando a coluna da tabela, logo, no caso dessa entidade, teremos uma tabela chamada “estado” com as colunas “id”, “nome”, “uf” e “pais”. Por padrão, tipos strings(representados por varchar no banco de dados) quando não possuem o campo “length” especificado, assume o valor de 255 caracteres(padrão do varchar).

Como de costume em OOP, para gerenciar os dados das variáveis externamente será necessário criar seus métodos get/set. Normalmente IDEs de desenvolvimento(Eclipse, NetBeans e phpStorm) conseguem inserir automaticamente para você. No caso da classe deste exemplo, estarei adicionado os métodos abaixo.

//...
public function getId()
{
	return $this->id;
}

public function setId($id)
{
	$this->id = $id;
	return $this;
}

public function getNome()
{
	return $this->nome;
}

public function setNome($nome)
{
	$this->nome = $nome;
	return $this;
}

public function getUf()
{
	return $this->uf;
}

public function setUf($uf)
{
	$this->uf = $uf;
	return $this;
}

public function getPais()
{
	return $this->pais;
}

public function setPais($pais)
{
	$this->pais = $pais;
	return $this;
}
//...

Com as suas entidades criadas, vamos criar as estruturas do banco de dados através dos comandos do Doctrine. Utilize o comando abaixo de acordo com a framework utilizada.

# Symfony 2
$ php app/console doctrine:schema:create

# Zend Framework 2
$ php public/index.php orm:schema-tool:create

Pronto! Suas tabelas foram criadas de acordo com as entidades existentes. Caso crie novas entidades ou altere alguma variável das já existentes, você deverá atualizar seu banco de dados utilizando o comando abaixo.

# Symfony 2
$ php app/console doctrine:schema:update --dump-sql --force

# Zend Framework 2
$ php public/index.php orm:schema-tool:update --dump-sql --force

No comando acima a chave “–dump-sql” te mostrará as querys que o Doctrine executará para atualizar seu banco de dados. A chave “–force” força o comando a executar as querys. Essas chaves poderão ser usadas ou não, de acordo com sua vontade.

Ok! Temos entidades criadas, nosso banco de dados está criado/atualizado, agora iremos pesquisar e registrar dados.  No exemplo abaixo o método chamado para atribuir valor a variável $em é diferido conforme a framework que esteja utilizando(Symfony ou Zend Framework). A diferença será informada no exemplo abaixo.

As lógica de inserção/pesquisa/alteração deverá estar em sua controller. No exemplo abaixo estou inserindo o estado do Rio de Janeiro ao executar minha action “add”.

//...
public function addAction()
{
	//Zend Framework
	$em = $this
		->getServiceLocator()
		->get('Doctrine\ORM\EntityManager')
	;

	//Symfony
	$em = $this
		->getDoctrine()
		->getManager()
	;

	//Criando um novo registro de estado
	$estado = new \AppBundle\Entity\Estado();
	$estado
		->setNome('Rio de Janeiro')
		->setUf('RJ')
		->setPais('BR')
	;

	//Armazenando um registro novo no banco de dados
	$em->persist($estado);
	$em->flush();

	//Mesmo não informando ID, após armazenado no banco de dados
	//a variável é preenchida pelo Doctrine.
	var_dump($estado->getId());
}
//...

Agora em minha action index, irei executar uma Query DQL para pesquisar todos os registros. O resultado da mesma será um array com os objetos relacionados ao registro das mesmas.

//...
public function indexAction()
{
	//Zend Framework
	$em = $this
		->getServiceLocator()
		->get('Doctrine\ORM\EntityManager')
	;

	//Symfony
	$em = $this
		->getDoctrine()
		->getManager()
	;

	//Query DQL para listar objetos "estado" registrados
	$estados = $em
		->createQuery('SELECT e FROM \AppBundle\Entity\Estado e')
		->getResult()
	;

	//Listará os resultados
	foreach ($estados as $estado) {
		echo sprintf(
			'ID do estado: %s, Nome do estado: %s, UF do estado: %s, País do estado: %d',
			$estado->getId(),
			$estado->getNome(),
			$estado->getUf(),
			$estado->getPais()
		);
	}
}
//...

Já sabemos inserir e listar dados, para editar dados basta apenas modificar dados e entidades persistidas e em seguida executar o método flush(). Abaixo estou utilizando um exemplo onde executo uma Query DQL para retornar um único objeto de estado e em seguida, altero seus dados.

//...
//Zend Framework
$em = $this
	->getServiceLocator()
	->get('Doctrine\ORM\EntityManager')
;

//Symfony
$em = $this
	->getDoctrine()
	->getManager()
;

try {
	//Na query DQL abaixo, estou criando uma condição onde atribuo o valor de ID.
	//Nesse caso, ":id" corresponde ao primeiro valor inserido ao setParameter.
	//":id" não precisa ter o mesmo nome do campo no qual está sendo tratado, poderá ser utilizado qualquer nome.
	$estado = $em
		->createQuery('SELECT e FROM \AppBundle\Entity\Estado e WHERE e.id = :id')
		->setParameter('id', 1)
		->getSingleResult()
	;
} catch (\Doctrine\ORM\NoResultException $e) {
	echo 'Registro não encontrado';
}

//Editando o estado 'Rio de Janeiro', considerando que o mesmo possui ID 1.
$estado
	->setNome('São Paulo')
	->setUf('SP')
;

//Atualizando os dados alterados no banco de dados.
$em->flush();
//...

Com isso, concluímos a parte 2 da sequencia de posts relacionada ao guia do Doctrine. Nos próximos posts dessa sequencia estarei ensinando como atribuir relacionamentos entre entidades(one-to-one, one-to-many, many-to-one, many-to-many) e demais comandos do Doctrine.

Links complementares

Tipo de dados – Doctrine

Espero que tenham gostado. Até a próxima pessoal!

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s