🗄️ Doctrine ORM

Gérer la base de données avec des objets PHP

Entités • Relations • Requêtes • Migrations

Formation DWWM - 2026

Au programme 📋

• 🎯 Qu'est-ce que Doctrine ORM ?
• ⚙️ Installation et configuration
• 📦 Entités et propriétés
• 🔗 Relations entre entités
• 💾 EntityManager et persistance
• 🔍 Repository et requêtes simples
• 🏗️ QueryBuilder avancé
• 📝 DQL (Doctrine Query Language)
• 🔄 Migrations de base de données
• 🌱 Fixtures (jeux de données)

Qu'est-ce que Doctrine ORM ?

Object-Relational Mapping

C'est quoi un ORM ? 🤔

ORM = Object-Relational Mapping = Faire correspondre des objets PHP avec des tables SQL.

Sans ORM vs Avec Doctrine 🆚

// Créer un utilisateur
$sql = "INSERT INTO user (name, email, created_at) 
        VALUES (?, ?, ?)";
$stmt = $pdo->prepare($sql);
$stmt->execute([
    'Marie', 
    'marie@example.com', 
    date('Y-m-d H:i:s')
]);
$userId = $pdo->lastInsertId();

// Récupérer un utilisateur
$sql = "SELECT * FROM user WHERE id = ?";
$stmt = $pdo->prepare($sql);
$stmt->execute([$userId]);
$userData = $stmt->fetch();

// Modifier
$sql = "UPDATE user SET email = ? WHERE id = ?";
$stmt = $pdo->prepare($sql);
$stmt->execute(['new@example.com', $userId]);

// Supprimer
$sql = "DELETE FROM user WHERE id = ?";
$stmt = $pdo->prepare($sql);
$stmt->execute([$userId]);

// Créer un utilisateur
$user = new User();
$user->setName('Marie');
$user->setEmail('marie@example.com');
$user->setCreatedAt(new \DateTime());

$entityManager->persist($user);
$entityManager->flush();

// Récupérer un utilisateur
$user = $repository->find($userId);

// Modifier
$user->setEmail('new@example.com');
$entityManager->flush();

// Supprimer
$entityManager->remove($user);
$entityManager->flush();

Le mapping Objet ↔ Table 🔗

Installation et Configuration

Préparer Doctrine

Installer Doctrine 📥

Commande d'installation

composer require symfony/orm-pack
composer require --dev symfony/maker-bundle

Fichiers créés

config/
├── packages/
│   └── doctrine.yaml      # Configuration Doctrine
└── .env                   # Variables d'environnement

src/
├── Entity/                # Dossier des entités (vide)
└── Repository/            # Dossier des repositories (vide)

Configurer la base de données 🔧

Modifier le fichier .env pour configurer la connexion :

MySQL / MariaDB

# .env
DATABASE_URL="mysql://utilisateur:motdepasse@127.0.0.1:3306/nom_base?serverVersion=8.0"

# Exemples réels :
# DATABASE_URL="mysql://root:@127.0.0.1:3306/mon_blog"
# DATABASE_URL="mysql://dwwm:secret@127.0.0.1:3306/symfony_app"

PostgreSQL

DATABASE_URL="postgresql://utilisateur:motdepasse@127.0.0.1:5432/nom_base?serverVersion=15&charset=utf8"

SQLite (développement)

DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"

Créer la base de données 🗄️

Commande de création

php bin/console doctrine:database:create

Created database `mon_blog` for connection named default

Autres commandes utiles

# Supprimer la base de données
php bin/console doctrine:database:drop --force

# Vérifier la connexion
php bin/console doctrine:query:sql "SELECT 1"

Entités et Propriétés

Les classes qui représentent vos tables

C'est quoi une Entité ? 📦

Une Entité est une classe PHP qui représente une table en base de données.

Créer une entité 🏗️

Commande interactive

php bin/console make:entity

Exemple de création : Article

$ php bin/console make:entity Article

Class name of the entity to create or update (e.g. BraveChef):
> Article

New property name (press <return> to stop adding fields):
> title

Field type (enter ? to see all types) [string]:
> string

Field length [255]:
> 255

Can this field be null in the database (nullable) (yes/no) [no]:
> no

New property name (press <return> to stop adding fields):
> content

Field type [string]:
> text

Can this field be null in the database (nullable) (yes/no) [no]:
> no

New property name (press <return> to stop adding fields):
> createdAt

Field type [string]:
> datetime

Can this field be null in the database (nullable) (yes/no) [no]:
> no

New property name (press <return> to stop adding fields):
> (appuyer sur Entrée pour finir)

Code de l'entité générée 💻

src/Entity/Article.php

<?php
namespace App\Entity;

use App\Repository\ArticleRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ArticleRepository::class)]
class Article
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $title = null;

    #[ORM\Column(type: Types::TEXT)]
    private ?string $content = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE)]
    private ?\DateTimeInterface $createdAt = null;

    // Getters et Setters générés automatiquement
    
    public function getId(): ?int
    {
        return $this->id;
    }

    public function getTitle(): ?string
    {
        return $this->title;
    }

    public function setTitle(string $title): static
    {
        $this->title = $title;
        return $this;
    }
    
    // ... autres getters/setters
}

Comprendre les attributs Doctrine 🏷️

#[ORM\Entity]

#[ORM\Entity(repositoryClass: ArticleRepository::class)]
class Article

Indique que cette classe est une entité Doctrine avec son repository associé.

#[ORM\Id] et #[ORM\GeneratedValue]

#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int $id = null;

Clé primaire auto-incrémentée (comme id INT AUTO_INCREMENT PRIMARY KEY).

#[ORM\Column]

#[ORM\Column(length: 255)]
private ?string $title = null;

Colonne VARCHAR(255) en SQL.

#[ORM\Column(type: Types::TEXT)]
private ?string $content = null;

Colonne TEXT en SQL (pour longs textes).

Types de colonnes Doctrine 📊

Options de colonne 🎛️

Options courantes

Exemples complets

// Email unique
#[ORM\Column(length: 180, unique: true)]
private ?string $email = null;

// Prix avec 2 décimales
#[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
private ?string $price = null;

// Description optionnelle
#[ORM\Column(type: Types::TEXT, nullable: true)]
private ?string $description = null;

// Booléen avec valeur par défaut
#[ORM\Column(options: ['default' => false])]
private ?bool $isPublished = false;

Relations entre Entités

Lier les tables entre elles

Les 4 types de relations 🔗

ManyToOne - Plusieurs vers Un 👥→👤

Cas d'usage : Plusieurs articles appartiennent à UNE catégorie.

Créer la relation

php bin/console make:entity Article

New property name (press <return> to stop adding fields):
> category

Field type (enter ? to see all types) [string]:
> relation

What class should this entity be related to?:
> Category

Relation type? [ManyToOne, OneToMany, ManyToMany, OneToOne]:
> ManyToOne

Is the Article.category property allowed to be null (nullable)? (yes/no) [yes]:
> no

Do you want to add a new property to Category so that you can access/update 
Article objects from it - e.g. $category->getArticles()? (yes/no) [yes]:
> yes

New field name inside Category [articles]:
> articles

Do you want to automatically delete orphaned App\Entity\Article objects 
(orphanRemoval)? (yes/no) [no]:
> no

Code généré - ManyToOne 💻

src/Entity/Article.php

#[ORM\ManyToOne(inversedBy: 'articles')]
#[ORM\JoinColumn(nullable: false)]
private ?Category $category = null;

public function getCategory(): ?Category
{
    return $this->category;
}

public function setCategory(?Category $category): static
{
    $this->category = $category;
    return $this;
}

src/Entity/Category.php

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

#[ORM\OneToMany(targetEntity: Article::class, mappedBy: 'category')]
private Collection $articles;

public function __construct()
{
    $this->articles = new ArrayCollection();
}

/**
 * @return Collection<int, Article>
 */
public function getArticles(): Collection
{
    return $this->articles;
}

public function addArticle(Article $article): static
{
    if (!$this->articles->contains($article)) {
        $this->articles->add($article);
        $article->setCategory($this);
    }
    return $this;
}

public function removeArticle(Article $article): static
{
    if ($this->articles->removeElement($article)) {
        if ($article->getCategory() === $this) {
            $article->setCategory(null);
        }
    }
    return $this;
}

Utiliser la relation ManyToOne 🎯

Créer un article avec catégorie

// Récupérer une catégorie
$category = $categoryRepository->find(1);

// Créer un article
$article = new Article();
$article->setTitle('Mon article');
$article->setContent('Contenu...');
$article->setCategory($category);  // ← Associer la catégorie

$entityManager->persist($article);
$entityManager->flush();

Afficher la catégorie d'un article

$article = $articleRepository->find(1);

// Accéder à la catégorie
echo $article->getCategory()->getName();

// Dans Twig
{{ article.category.name }}

Afficher tous les articles d'une catégorie

$category = $categoryRepository->find(1);

// Parcourir les articles
foreach ($category->getArticles() as $article) {
    echo $article->getTitle();
}

// Dans Twig
{% for article in category.articles %}
    <h3>{{ article.title }}</h3>
{% endfor %}

ManyToMany - Plusieurs vers Plusieurs 👥↔👥

Cas d'usage : Un article peut avoir plusieurs tags, un tag peut être sur plusieurs articles.

Créer la relation

php bin/console make:entity Article

New property name (press <return> to stop adding fields):
> tags

Field type (enter ? to see all types) [string]:
> relation

What class should this entity be related to?:
> Tag

Relation type? [ManyToOne, OneToMany, ManyToMany, OneToOne]:
> ManyToMany

Do you want to add a new property to Tag so that you can access/update 
Article objects from it - e.g. $tag->getArticles()? (yes/no) [yes]:
> yes

Code généré - ManyToMany 💻

src/Entity/Article.php

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

#[ORM\ManyToMany(targetEntity: Tag::class, inversedBy: 'articles')]
private Collection $tags;

public function __construct()
{
    $this->tags = new ArrayCollection();
}

/**
 * @return Collection<int, Tag>
 */
public function getTags(): Collection
{
    return $this->tags;
}

public function addTag(Tag $tag): static
{
    if (!$this->tags->contains($tag)) {
        $this->tags->add($tag);
    }
    return $this;
}

public function removeTag(Tag $tag): static
{
    $this->tags->removeElement($tag);
    return $this;
}

Utiliser la relation ManyToMany 🎯

Ajouter des tags à un article

$article = new Article();
$article->setTitle('Mon article');

$tag1 = $tagRepository->findOneBy(['name' => 'PHP']);
$tag2 = $tagRepository->findOneBy(['name' => 'Symfony']);

$article->addTag($tag1);
$article->addTag($tag2);

$entityManager->persist($article);
$entityManager->flush();

Afficher les tags d'un article

$article = $articleRepository->find(1);

foreach ($article->getTags() as $tag) {
    echo $tag->getName();
}

// Dans Twig
{% for tag in article.tags %}
    <span class="badge">{{ tag.name }}</span>
{% endfor %}

Afficher les articles d'un tag

$tag = $tagRepository->findOneBy(['name' => 'PHP']);

foreach ($tag->getArticles() as $article) {
    echo $article->getTitle();
}

OneToOne - Un vers Un 👤↔👤

Cas d'usage : Un utilisateur a UN profil, un profil appartient à UN utilisateur.

Code exemple

// Dans User.php
#[ORM\OneToOne(targetEntity: Profile::class, mappedBy: 'user', cascade: ['persist', 'remove'])]
private ?Profile $profile = null;

// Dans Profile.php
#[ORM\OneToOne(targetEntity: User::class, inversedBy: 'profile')]
#[ORM\JoinColumn(nullable: false)]
private ?User $user = null;

Utilisation

$user = new User();
$user->setEmail('user@example.com');

$profile = new Profile();
$profile->setBio('Développeur passionné');
$profile->setUser($user);

$entityManager->persist($user);
$entityManager->persist($profile);
$entityManager->flush();

// Accès
echo $user->getProfile()->getBio();
echo $profile->getUser()->getEmail();

EntityManager et Persistance

Sauvegarder et manipuler les données

C'est quoi l'EntityManager ? 🎛️

EntityManager = Le chef d'orchestre de Doctrine. Il gère TOUTES les opérations sur la base de données.

Injecter l'EntityManager 💉

Dans un contrôleur

use Doctrine\ORM\EntityManagerInterface;

class ArticleController extends AbstractController
{
    #[Route('/article/create', name: 'article_create')]
    public function create(EntityManagerInterface $entityManager): Response
    {
        // $entityManager est automatiquement injecté
        
        $article = new Article();
        $article->setTitle('Mon article');
        $article->setContent('Contenu...');
        
        $entityManager->persist($article);
        $entityManager->flush();
        
        return new Response('Article créé avec ID : ' . $article->getId());
    }
}

persist() et flush() 💾

persist() - Préparer

$article = new Article();
$article->setTitle('Titre');

$entityManager->persist($article);
// ← L'objet est "tracké" mais PAS ENCORE en base !

flush() - Exécuter

$entityManager->flush();
// ← MAINTENANT les requêtes SQL sont exécutées

Pourquoi séparer persist() et flush() ?

Exemple : Créer plusieurs objets

for ($i = 1; $i <= 100; $i++) {
    $article = new Article();
    $article->setTitle("Article $i");
    $entityManager->persist($article);
}

// UNE SEULE requête SQL pour tout insérer
$entityManager->flush();

Opérations CRUD complètes 🔄

CREATE - Créer

$article = new Article();
$article->setTitle('Nouveau');
$article->setContent('Contenu');

$entityManager->persist($article);
$entityManager->flush();

// L'ID est maintenant disponible
echo $article->getId();

READ - Lire

// Via repository (voir partie suivante)
$article = $articleRepository->find(1);

UPDATE - Modifier

$article = $articleRepository->find(1);
$article->setTitle('Titre modifié');

// PAS BESOIN de persist() pour un objet déjà en base !
$entityManager->flush();

DELETE - Supprimer

$article = $articleRepository->find(1);

$entityManager->remove($article);
$entityManager->flush();

Repository et Requêtes

Chercher et filtrer les données

C'est quoi un Repository ? 📚

Repository = Bibliothèque de méthodes pour chercher des entités.

Obtenir un Repository 🎯

Méthode 1 : Via EntityManager

$repository = $entityManager->getRepository(Article::class);
$article = $repository->find(1);

Méthode 2 : Injection directe (recommandée)

use App\Repository\ArticleRepository;

class ArticleController extends AbstractController
{
    #[Route('/article/{id}', name: 'article_show')]
    public function show(int $id, ArticleRepository $repository): Response
    {
        $article = $repository->find($id);
        
        if (!$article) {
            throw $this->createNotFoundException('Article introuvable');
        }
        
        return $this->render('article/show.html.twig', [
            'article' => $article
        ]);
    }
}

Méthodes de base du Repository 🔧

Exemples

// Par ID
$article = $repository->find(5);

// Tous
$articles = $repository->findAll();

// Par critères
$articles = $repository->findBy(['category' => $category]);

// Avec tri et limite
$articles = $repository->findBy(
    ['published' => true],      // Critères
    ['createdAt' => 'DESC'],    // Tri
    10,                          // Limite
    0                            // Offset
);

// Un seul résultat
$article = $repository->findOneBy(['slug' => 'mon-article']);

// Compter
$count = $repository->count(['published' => true]);

Créer des méthodes personnalisées 🎨

Vous pouvez ajouter vos propres méthodes dans le Repository !

src/Repository/ArticleRepository.php

namespace App\Repository;

use App\Entity\Article;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;

class ArticleRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Article::class);
    }

    /**
     * Trouver les articles publiés récents
     */
    public function findRecentPublished(int $limit = 10): array
    {
        return $this->createQueryBuilder('a')
            ->andWhere('a.published = :published')
            ->setParameter('published', true)
            ->orderBy('a.createdAt', 'DESC')
            ->setMaxResults($limit)
            ->getQuery()
            ->getResult();
    }

    /**
     * Chercher par titre
     */
    public function searchByTitle(string $query): array
    {
        return $this->createQueryBuilder('a')
            ->andWhere('a.title LIKE :query')
            ->setParameter('query', '%' . $query . '%')
            ->getQuery()
            ->getResult();
    }

    /**
     * Articles d'une catégorie avec nombre de commentaires
     */
    public function findByCategory(int $categoryId): array
    {
        return $this->createQueryBuilder('a')
            ->leftJoin('a.comments', 'c')
            ->addSelect('c')
            ->andWhere('a.category = :categoryId')
            ->setParameter('categoryId', $categoryId)
            ->orderBy('a.createdAt', 'DESC')
            ->getQuery()
            ->getResult();
    }
}

QueryBuilder Avancé

Construire des requêtes complexes

C'est quoi le QueryBuilder ? 🏗️

QueryBuilder = Constructeur de requêtes SQL en PHP orienté objet.

Syntaxe de base du QueryBuilder 📝

Structure complète

$qb = $repository->createQueryBuilder('a')  // Alias 'a' pour Article
    ->andWhere('a.published = :published')   // Condition
    ->setParameter('published', true)        // Paramètre sécurisé
    ->orderBy('a.createdAt', 'DESC')        // Tri
    ->setMaxResults(10)                      // Limite
    ->getQuery()                             // Construire la requête
    ->getResult();                           // Exécuter et récupérer

SQL équivalent

SELECT * FROM article a
WHERE a.published = true
ORDER BY a.created_at DESC
LIMIT 10

Méthodes du QueryBuilder 🔧

Paramètres sécurisés 🔒

// NE JAMAIS FAIRE ÇA !
$title = $_GET['title'];
->where("a.title = '$title'")  // ← FAILLE DE SÉCURITÉ !

->where('a.title = :title')
->setParameter('title', $title)  // ← Protection automatique

Plusieurs paramètres

->andWhere('a.category = :category')
->andWhere('a.published = :published')
->setParameter('category', $category)
->setParameter('published', true)

// OU avec tableau
->setParameters([
    'category' => $category,
    'published' => true
])

Jointures avec QueryBuilder 🔗

INNER JOIN (join)

// Articles avec leur catégorie
$qb = $repository->createQueryBuilder('a')
    ->join('a.category', 'c')        // Jointure
    ->addSelect('c')                  // Charger aussi la catégorie
    ->where('c.name = :categoryName')
    ->setParameter('categoryName', 'Tech')
    ->getQuery()
    ->getResult();

LEFT JOIN (leftJoin)

// Articles même sans catégorie
$qb = $repository->createQueryBuilder('a')
    ->leftJoin('a.category', 'c')
    ->addSelect('c')
    ->getQuery()
    ->getResult();

Jointures multiples

// Articles avec catégorie ET tags
$qb = $repository->createQueryBuilder('a')
    ->leftJoin('a.category', 'c')
    ->leftJoin('a.tags', 't')
    ->addSelect('c', 't')
    ->getQuery()
    ->getResult();

Agrégations (COUNT, SUM, AVG...) 📊

Compter

// Nombre d'articles publiés
$count = $repository->createQueryBuilder('a')
    ->select('COUNT(a.id)')
    ->where('a.published = true')
    ->getQuery()
    ->getSingleScalarResult();  // Retourne un nombre

Somme

// Total des vues
$totalViews = $repository->createQueryBuilder('a')
    ->select('SUM(a.views)')
    ->getQuery()
    ->getSingleScalarResult();

Moyenne

// Note moyenne
$avgRating = $repository->createQueryBuilder('a')
    ->select('AVG(a.rating)')
    ->getQuery()
    ->getSingleScalarResult();

GROUP BY

// Nombre d'articles par catégorie
$stats = $repository->createQueryBuilder('a')
    ->select('c.name, COUNT(a.id) as nb_articles')
    ->join('a.category', 'c')
    ->groupBy('c.id')
    ->getQuery()
    ->getResult();

DQL - Doctrine Query Language

SQL orienté objet

C'est quoi DQL ? 📝

DQL = Doctrine Query Language = SQL mais avec des noms d'objets au lieu de tables.

SELECT * 
FROM article a
JOIN category c ON a.category_id = c.id
WHERE a.published = 1
ORDER BY a.created_at DESC
LIMIT 10

SELECT a, c 
FROM App\Entity\Article a
JOIN a.category c
WHERE a.published = true
ORDER BY a.createdAt DESC

Utiliser DQL dans un Repository 💻

Méthode 1 : DQL pur

public function findRecentPublished(): array
{
    $dql = 'SELECT a 
            FROM App\Entity\Article a
            WHERE a.published = :published
            ORDER BY a.createdAt DESC';
    
    return $this->getEntityManager()
        ->createQuery($dql)
        ->setParameter('published', true)
        ->setMaxResults(10)
        ->getResult();
}

Méthode 2 : QueryBuilder (recommandé)

public function findRecentPublished(): array
{
    return $this->createQueryBuilder('a')
        ->where('a.published = :published')
        ->setParameter('published', true)
        ->orderBy('a.createdAt', 'DESC')
        ->setMaxResults(10)
        ->getQuery()
        ->getResult();
}

Migrations de Base de Données

Synchroniser le schéma SQL

C'est quoi une migration ? 🔄

Migration = Fichier PHP qui contient les modifications SQL à appliquer à la base de données.

Créer et exécuter une migration 🏗️

Étape 1 : Créer les entités

php bin/console make:entity Article

Étape 2 : Générer la migration

php bin/console make:migration

migrations/Version20250128143000.php

Étape 3 : Exécuter la migration

php bin/console doctrine:migrations:migrate

Contenu d'une migration 📄

migrations/Version20250128143000.php

<?php
namespace DoctrineMigrations;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;

final class Version20250128143000 extends AbstractMigration
{
    public function getDescription(): string
    {
        return 'Create article table';
    }

    public function up(Schema $schema): void
    {
        // Migration "forward" - créer/modifier
        $this->addSql('CREATE TABLE article (
            id INT AUTO_INCREMENT NOT NULL, 
            title VARCHAR(255) NOT NULL, 
            content LONGTEXT NOT NULL, 
            created_at DATETIME NOT NULL, 
            PRIMARY KEY(id)
        ) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci`');
    }

    public function down(Schema $schema): void
    {
        // Migration "backward" - annuler
        $this->addSql('DROP TABLE article');
    }
}

Commandes de migration 🛠️

Fixtures - Jeux de Données

Remplir la base avec des données de test

C'est quoi des Fixtures ? 🌱

Fixtures = Données de test qu'on charge dans la base de données pour développer.

Installer DoctrineFixturesBundle 📥

Commande d'installation

composer require --dev orm-fixtures

Créer des Fixtures 🏗️

src/DataFixtures/AppFixtures.php

<?php
namespace App\DataFixtures;

use App\Entity\Article;
use App\Entity\Category;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;

class AppFixtures extends Fixture
{
    public function load(ObjectManager $manager): void
    {
        // Créer des catégories
        $categories = [];
        $categoryNames = ['Tech', 'Sport', 'Culture', 'Politique'];
        
        foreach ($categoryNames as $name) {
            $category = new Category();
            $category->setName($name);
            $manager->persist($category);
            $categories[] = $category;
        }

        // Créer 20 articles
        for ($i = 1; $i <= 20; $i++) {
            $article = new Article();
            $article->setTitle("Article n°$i");
            $article->setContent("Contenu de l'article n°$i...");
            $article->setCreatedAt(new \DateTime());
            
            // Assigner une catégorie aléatoire
            $randomCategory = $categories[array_rand($categories)];
            $article->setCategory($randomCategory);
            
            $manager->persist($article);
        }

        // Tout sauvegarder en base
        $manager->flush();
    }
}

Charger les Fixtures 🌱

Commande

php bin/console doctrine:fixtures:load

Careful, database "mon_blog" will be purged. Do you want to continue? (yes/no) [no]:
> yes

Charger sans confirmation (scripts automatiques)

php bin/console doctrine:fixtures:load --no-interaction

Ajouter sans supprimer (append)

php bin/console doctrine:fixtures:load --append

Fixtures réalistes avec Faker 🎭

Installer Faker

composer require --dev fakerphp/faker

Utiliser Faker dans les fixtures

<?php
namespace App\DataFixtures;

use App\Entity\Article;
use App\Entity\User;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;
use Faker\Factory;

class AppFixtures extends Fixture
{
    public function load(ObjectManager $manager): void
    {
        $faker = Factory::create('fr_FR');  // Données en français

        // Créer 50 utilisateurs
        $users = [];
        for ($i = 0; $i < 50; $i++) {
            $user = new User();
            $user->setName($faker->name());
            $user->setEmail($faker->email());
            $user->setCreatedAt($faker->dateTimeBetween('-2 years'));
            
            $manager->persist($user);
            $users[] = $user;
        }

        // Créer 100 articles
        for ($i = 0; $i < 100; $i++) {
            $article = new Article();
            $article->setTitle($faker->sentence());
            $article->setContent($faker->paragraphs(5, true));
            $article->setCreatedAt($faker->dateTimeBetween('-1 year'));
            $article->setViews($faker->numberBetween(0, 10000));
            $article->setPublished($faker->boolean(80));  // 80% publiés
            $article->setAuthor($faker->randomElement($users));
            
            $manager->persist($article);
        }

        $manager->flush();
    }
}

Méthodes Faker utiles 🎨

Ce qu'on a appris

Workflow complet Doctrine 🔄

1. Configurer la connexion BDD
   Modifier .env avec DATABASE_URL
2. Créer la base de données
   php bin/console doctrine:database:create
3. Créer les entités
   php bin/console make:entity
4. Générer la migration
   php bin/console make:migration
5. Exécuter la migration
   php bin/console doctrine:migrations:migrate
6. Créer les fixtures (optionnel)
   Éditer src/DataFixtures/AppFixtures.php
7. Charger les fixtures
   php bin/console doctrine:fixtures:load

Commandes essentielles 🛠️

Concepts clés Doctrine 📚

Types de relations résumés 🔗

Utilisation

// Accéder à la relation
$article->getCategory()->getName();
$category->getArticles();  // Collection

// Ajouter à une relation ManyToMany
$article->addTag($tag);

// Définir une relation ManyToOne
$article->setCategory($category);

Bonnes pratiques Doctrine 💡

1. Toujours utiliser les migrations
   Historique traçable, déploiement sûr
2. Méthodes personnalisées dans le Repository
   Ne pas mettre de requêtes dans les contrôleurs
3. Utiliser QueryBuilder plutôt que DQL pur
   Plus lisible, moins d'erreurs de typo
4. Toujours utiliser des paramètres préparés
   setParameter() protège contre les injections SQL
5. Lazy loading des relations
   Doctrine charge les relations seulement quand nécessaire
6. Un seul flush() par requête HTTP
   Grouper les persist(), puis un seul flush()
7. Fixtures pour le développement
   Données réalistes avec Faker

Erreurs courantes à éviter ⚠️

$article = new Article();
$article->setTitle('Test');
$entityManager->persist($article);
// ❌ Oublié flush() → Rien en base !

// ✅ BON
$entityManager->flush();

$article = $repository->find(1);
$article->setTitle('Modifié');
$entityManager->persist($article);  // ❌ Inutile !
$entityManager->flush();

// ✅ BON - pas besoin de persist()
$article->setTitle('Modifié');
$entityManager->flush();

// ❌ DANGEREUX
->where("a.title = '$title'")

// ✅ SÛR
->where('a.title = :title')
->setParameter('title', $title)

Ressources pour aller plus loin 📚

Ce que vous maîtrisez maintenant ! 💪

🎓 Félicitations !

Vous maîtrisez Doctrine ORM

Prochaine étape : Les Formulaires ! 📝

Formation DWWM - 2026