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.

utilizando o VIM

Olá amigos, hoje vou iniciar uma sequencia legal sobre o editor de textos VIM.
O sistema Operacional GNU/LINUX possui um editor de texto chamado VIM, no qual pode ser utilizado em terminais para a edição de arquivos de texto.

O Vim  além de ser um editor de texto comum este também possui recursos para ser utilizado como um editor de programação, como por exemplo a mudança de usuário de comum para administrador, retirar senhas de usúario por algum motivo, editar configurações de arquivo, etc

Instalação do editor de texto VIM:

1. sudo apt-get install vim -y

Utilizando o editor de texto VIM para abrir um arquivo:

Super Usuário (root)
# vim [arquivo]

Usuário comum
$ vim [arquivo]

O editor de texto vim pode ser utilizado em dois modos diferentes:

modo de inserção de texto
modo de inserção de comandos

### MODO DE INSERÇÃO ###

Para entrar no modo de inserção de texto utilize:

aperte a tecla “I” ou a tecla “INSERT”

Através deste modo poderemos inserir texto no arquivo.

Para entrar no modo de substituição de texto aperte:

aperte a tecla “INSERT” 2x

Através deste modo poderemos substituir o texto dentro do documento, também chamado de modo REPLACE.

### Modo de comandos: ###
Salvar o arquivo

:w

Sair do arquivo

:q

Salvar e sair do arquivo

:wq

ou

:x

OBS: Caso queira forçar a execução de algum comando utilize “!”
Exemplo:
:q! -> Forçar a execução de saída do arquivo.
:w! -> Forçar a execução de salvar o arquivo.
:wq! ou :x! -> Forçar em salvar e sair ao mesmo tempo do arquivo.

Numerar as linhas do arquivo
:set number

Retirar a numeração imposta através do comando anterior
:set nonumber

Colocar Texto colorido
:syntax on

Retirar Texto Colorido
:syntax off

Pular para uma determinada linha
:Numero_de_linha

Exemplo:
Pular para a linha 15
:15

Ir com o cursor até o final do arquivo
:$

Ir com o cursor até o final do arquivo
:0

Inserir o conteúdo de um arquivo de texto dentro do arquivo no qual estiver editando
:r arquivo.txt

Executar um comando do shell sem sair do arquivo
:!COMANDO

Exemplo:
:!cat /etc/passwd

Executar um comando do shell e jogar a saída (RESULTADO) do comando para dentro do arquivo de texto
:r!COMANDO

Exemplo:
:r!cat /etc/passwd

Procurar por palavras dentro do arquivo de texto
/PALAVRA

Exemplo:
/futebol

Irá procurar a palavra futebol dentro de todo o arquivo, aperte a tecla “N” para pular para cada palavra futebol dentro do arquivo.

OBS: Através deste comando irá procurar do INÍCIO PARA O FINAL.

Procurar por palavras dentro do arquivo de texto
?PALAVRA

Exemplo:
?futebol

Irá procurar a palavra futebol dentro de todo o arquivo, aperte a tecla “N” para pular para cada palavra futebol dentro do arquivo.

OBS: Através deste comando irá procurar do FINAL PARA O INÍCIO.

Abrir uma sessão do sheel dentro do editor de texto
:shell

Para voltar ao arquivo digite: exit

Alterar palavras na linha atual
:s/palavra_antiga/palavra_nova/g

Exemplo:
:s/casa/CASA/g

Irá todas as palavras casa(minúsculas) na linha atual pela palavra CASA(MAIÚSCULAS).

Para alterar todas as palavras em todo o arquivo:
:%s/palavra_antiga/palavra_nova/g

Para manipular mais de um arquivo de texto ao mesmo tempo
:split [ARQUIVO] ou :sp [ARQUIVO]

Para alternar entre os dois arquivos utilize as teclas:
Ctrl+W

Selecionar texto

Utilize a tecla “V” em modo de comando.

Copiar texto:

Utilize a tecla “Y” em modo de comando.

Colar Texto:

Utilize a tecla “p” em modo de comando.

Apagar toda uma linha:

Utilize a tecla “D” 2x em modo de comando.

Copiar toda uma linha:

Utilize a tecla “Y” 2x em modo de comando.