Doctrine

En ligne de commande pour créer l'entité chose:

$ php app/console generate:doctrine:entity

Une série d'information est demandée

1. le nom de l'entité

   The Entity shortcut name: MachinTrucBundle:Chose

   Il faut être vigilant avec la syntaxe.

2. le format de configuration

   Configuration format (yml, xml, php, or annotation) [annotation]:

   Là on choisit annotation

3. les champs que l'on veut définir …

Et doctrine fait tout le boulot!

Lors de la création de l'entité avec doctrine, un minimum d'annotations est réalisées. Doctrine crée automatiquement un champ $id, clé primaire. Les getters et les setters sont déjà prêts.

namespace Machin\TrucBundle\Entity;

use Doctrine\ORM\Mapping as ORM;
/**
 *  Chose
 *
 * @ORM\Table(name="chose")
 * @ORM\Entity(repositoryClass="Machin\TrucBundle\Entity\ChoseRepository")
 */

class Chose
{

    /**
     * @var integer
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
    
    /**
     * @var string
     *
     * @ORM\Column(name="name", type="string", length=150, nullable=false, unique=true)
     */
    private $name;
    
    /**
     * @var decimal
     *
     * @ORM\Column(name="size", type="decimal", precision=3, scale=2)
     */
    private $size;

• targetEntity : REQUIS - l'entité à laquelle est liée la première (nom complet)
• cascade : objet comme par exemple {“remove”, “persist”}
  • “remove” pour suppression en cascade
  • “persist” pour insertion élément d'un sous-formulaire
  • …
• fetch : LAZY ou EAGER (LAZY ne charge que l'entité courante, EAGER charge aussi la (les) entité(s) liée(s)). LAZY par défaut
• inversedBy : champ inverse dans l'autre entité (bi-directionnel, dans chacune des entités je veux accéder à l'autre)
• mappedBy: le champ de l'autre entité correspondant (bi-directionnel)

• nullable : entité reliée requise ou non, par défaut nullable vaut true (pas requise)
• name: nom de la colonne de la table sur laquelle se fait la jointure (foreign key)
• referencedColumnName : le nom de la colonne dans l'autre table sur laquelle se fait la jointure (foreign key)

Par exemple, on a un Client auquel est lié une Carte.

class Client
{
     ...
     // JoinColumn n'est pas utile ici,
    /**
     * @ORM\OneToOne(targetEntity="Machin\TrucBundle\Entity\Carte", cascade={"remove", "persist"})
     * @ORM\JoinColumn(name="carte_id", referencedColumnName="id", nullable=true)
     */
     private $carte;
     ...
     public setCarte(Carte $carte){
        $this->carte = $carte;
     }

C'est bidirectionnel, mais c'est bien dans la table Client qu'on enregistre l“id” de la carte.

/*
 * @ORM\Entity(name="client")
 */
class Client
{
     ...
    /**
     * @ORM\OneToOne(targetEntity="Machin\TrucBundle\Entity\Carte", inversedBy="client" , cascade={"remove", "persist"})
     * @ORM\JoinColumn(name="carte_id", referencedColumnName="id", nullable=false)
     */
     private $carte;
     ...
     public function setCarte(Carte $carte)
     {
        $this->carte = $carte;
     }
     public function getCarte()
     {
        return $this->carte;
     }
 }

/*
 * @ORM\Entity(name="carte")
 */
class Carte
{
     ...
    /**
     * @ORM\OneToOne(targetEntity="Machin\TrucBundle\Entity\Client", mappedBy="carte")
     */
     private $client;
     ...
     public getClient(){
        return $this->client;
     }
 }

Cette fois-ci,le client peut avoir plusieurs cartes, mais c'est dans la table carte qu'on enregistre l'id du client! Et c'est bi-directionnel.

/*
 * @ORM\Entity(name="client")
 */
class Client
{
     ...
    /**
     * @ORM\OneToMany(targetEntity="Machin\TrucBundle\Entity\Carte", mappedBy="client" , cascade={"remove", "persist"})
     */
     private $cartes;
     ...
     public function __construct() {
        $this->cartes = new ArrayCollection();
     }
     public function addCarte(Carte $carte)
     {
        $this->cartes[] = $carte;
        return $this;
     }
     public function removeCarte(Carte $carte)
     {
        $this->cartes->removeElement($carte);
        return $this;
     }
     public getCartes()
     {
        return $this->cartes;
     }
     
 }

/*
 * @ORM\Entity(name="carte")
 */
class Carte
{
     ...
    /**
     * @ORM\ManyToOne(targetEntity="Machin\TrucBundle\Entity\Client", inversedBy="cartes")
     * @ORM\JoinColumn(name="client_id", referencedColumnName="id")
     */
     private $client;
     ...
     public getClient(){
        return $this->client;
     }
 }

Par exemple des Livres et des Auteurs. On a donc une table de liaison livres_auteurs.

/*
 * @ORM\Entity(name="auteur")
 */
class Auteur
{
     ...
    /**
     * @ORM\ManyToMany(targetEntity="Machin\TrucBundle\Entity\Livre", mappedBy="auteurs" , cascade={"persist"})
     */
     private $livres;
     ...
     public function __construct() {
        $this->livres = new ArrayCollection();
     }

 }

/*
 * @ORM\Entity(name="livre")
 */
class Livre
{
     ...
    /**
     * @ORM\ManyToMany(targetEntity="Machin\TrucBundle\Entity\Auteur", inversedBy="livres")
     * @ORM\JoinTable(name="livres_auteurs")
     */
     private $auteurs;
     ...
     public function __construct() {
        $this->auteurs = new ArrayCollection();
     }
 }

On peut faire plein d'autres liaisons, des liaisons d'une entités sur elle-même. http://doctrine-orm.readthedocs.org/projects/doctrine-orm/en/latest/reference/association-mapping.html

Une fois créées toutes les entités, on peut en ligne de commandes avec doctrine, tout mettre à jour.

php app/console doctrine:database:create

php app/console doctrine:schema:update --dump-sql

php app/console doctrine:schema:update --force

Paramétrage