Annotations no Doctrine - @Column

Nesse post vou falar um pouco sobre as Annotations no Doctrine buscando deixar essa página como guia de consulta rápida para vc escrever suas entidades ok?

O que vc precisa saber para entender esse artigo:

• Lógica de programação
• PHP
• POO
• ORM
• Conhecer pelo menos o básico de Doctrine

Bem, o que são essas annotations? Para quem conhece Java sabe que é indiscutível a agilidade e facilidade de configuração que as annotations proporcionam, elas são formas de descrever toda uma classe através de comentários.

Com o objetivo de trazer tal comodidade ao PHP surgiu o projeto Addendum – escrito por Jan Suchal – que permite via Reflection acessar as annotations das classes.

As annotations devem ser escritas em blocos de comentários, uma vez que o @ (caracter que inicia uma annotation) é um caractere reservado no PHP. Elas podem ser mono ou multi valoradas de acordo com os exemplos abaixo.

1. // Custom annotation  
2. class Persistent extends Annotation {}  
4. // Custom annotation  
5. class Table extends Annotation {}  
7. // Multi valued annotation  
8. class Secured extends Annotation {  
9.    public $role;  
10.    public $level;  
11. }  
13. /**  
14.  * @Persistent  
15.  * @Table("people")
16.  * @Secured(role = "admin", level = 2)
17.  */  
18. class Person {  
19.    // some code  
20. }  
22. // getting the annotation by class name  
23. $reflection = new ReflectionAnnotatedClass('Person');  
25. // getting the annotation by instance  
26. $person = new Person();  
27. $reflection = new ReflectionAnnotatedClass($person);  
29. // true  
30. $reflection->hasAnnotation('Persistent');  
32. // contains string "people"  
33. $reflection->getAnnotation('Table')->value;

No doctrine usamos as annotations para descrever uma classe que representa uma entidade do sistema ou seja, uma tabela no banco, seguindo a mesma onda da JPA, facilitando a configuração das classes de persistência e seus relacionamentos.

1. /**
2.  * @DoctrineEntity(tableName="pessoa")
3.  */  
4. class Pessoa {  
6.    /**
7.     * @DoctrineId
8.     * @DoctrineColumn(type="integer")
9.     * @DoctrineIdGenerator("auto")
10.     */  
11.    public $id;  
13.    /**
14.     * @DoctrineColumn(type="varchar", length=255)
15.     */  
16.    public $nome;  
18.    /**
19.     * @DoctrineColumn(type="varchar")
20.     */  
21.    public $sobrenome;  
23.    /**
24.     * @DoctrineManyToOne(targetEntity="Usuario",
25.            joinColumns={"user_id" = "id"})
26.     */  
27.    public $usuario;  
28.    
29. }

Vejam que acabamos de criar uma entidade pessoa onde apontamos os campos e os tipos dos campos, no ultimo uma outra entidade(usuario) montando o relacionamento ManyToOne.



Bem eu precisei dar essa parte básica do Doctrine para finalmente montarmos uma relação das annotations então, chega de enrolar.



Annotations Doctrine

@Column (O mais utilizado, e o mais básico)
Esse é o carinha que define a maioria das colunas que criamos dentro de nossas entidades, o proprio nome diz, é ele que marca um atributo como uma coluna válida no banco. Qualquer espera de valor dentro desta variável será salvo e carregado a partir do banco de dados como parte do ciclo de vida das variáveis ​​de instância da entidade de classe.

Atributos requeridos:

• type: Tipo do atributo para que seja criado a coluna no banco baseado nesse tipo como por exemplo char, int etc...

Atributos opcionais:

• name: Por padrão o nome do atributo é o nome da coluna no banco(sem o $ é claro), mas pe possível determinar um outro nome para a coluna utilizando o name.
• length: Usado para tipo "string" serve para determinar o limite máximo de caracteres dessa coluna. O Doctrine não valida o tamanho da string no funcionamento do sistema, oque aconteceria era um funcionamento comum onde apenas o limite liberado é que seria gravado no banco de dados.
• precision: Marca a precisão de números decimais(número exato) da coluna (Aplicado apenas para colunas decimais)
• scale: The scale for a decimal (exact numeric) column (Applies only for decimal column)
• unique: Valor booleano que determina se o valo é unico.
• nullable: Determina se coluna pode ser NULL.
• columnDefinition:  DDL SQL trecho que se inicia após o nome da coluna e especifica a definição de coluna completa (non-portable!). Este atributo permite fazer uso de recursos avançados RMDBS. No entanto, você deve fazer uso cuidadoso deste recurso tomando cuidado com as conseqüências. SchemaTool não irá detectar alterações na coluna mais correctamente se você usar "ColumnDefinition".
  Além disso, você deve se lembrar que o "type" ainda lida com a conversão entre PHP e os valores do banco de dados. Se você usar esse atributo em uma coluna que é usada para junções entre tabelas você também deve dar uma olhada em @ JoinColumn.
  
  

Exemplos simples:

1. <?php
3. namespace GuestBook\Model\Doctrine\Entity;
5. /**
6.  *
7.  * @Table(name="guestbook")
8.  * @Entity
9.  */
10. class GuestBookDoctrine{
11.    
12.     /**
13.      * @var integer $id
14.      * @Column(type="integer")
15.      * @Id
16.      * @GeneratedValue(strategy="IDENTITY")
17.      */
18.     private $id;
19.    
20.     public function setId($id){$this->id = $id;}
21.     public function getId(){return $this->id;}
22.    
23.    
24.     /**
25.      * @Column(type="string", length="100")
26.      */
27.     private $title;
28.     public function setTitle($title){$this->title=$title;}
29.     public function getTitle(){return $this->title;}
30.    
31. }

Exemplo da documentação do doctrine:

<?php
/**
 * @Column(type="string", length=32, unique=true, nullable=false)
 */
protected $username;

/**
 * @Column(type="string", columnDefinition="CHAR(2) NOT NULL")
 */
protected $country;

/**
 * @Column(type="decimal", precision=2, scale=1)
 */
protected $height;

Bem acho que por hoje é só, até o próximo artigo sobre mais annotations do doctrine.