> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Seeding de base de données

> Comment utiliser la fonctionnalité de seeding de Laravel pour insérer des données d'exemple destinées au développement et aux tests.

## Qu'est-ce que le seeding

Le seeding est le mécanisme permettant d'insérer des données d'exemple ou des données initiales dans la base.

Lors de la mise en place d'un environnement de développement ou de tests automatisés, il est nécessaire de disposer d'un état pré-rempli. Comme saisir manuellement les données à chaque fois est coûteux, on regroupe le processus dans des seeders réexécutables.

Les classes de seeder sont stockées dans le répertoire `database/seeders`. Par défaut, une classe `DatabaseSeeder` est fournie.

```mermaid theme={null}
flowchart TD
    A["php artisan db:seed"] --> B["DatabaseSeeder::run()"]
    B --> C["UserSeeder::run()"]
    B --> D["PostSeeder::run()"]
    C --> E["Insertion dans la table users"]
    D --> F["Insertion dans la table posts"]
```

## Créer un seeder

Utilisez la commande Artisan `make:seeder` pour générer une nouvelle classe.

```shell theme={null}
php artisan make:seeder UserSeeder
```

Le fichier généré est placé dans `database/seeders/UserSeeder.php`.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder
{
    /**
     * Exécute le seeder.
     */
    public function run(): void
    {
        // Écrivez ici votre logique d'insertion
    }
}
```

## Implémenter le seeder

Écrivez la logique d'insertion dans la méthode `run()`. Vous pouvez utiliser la façade DB ou les modèles Eloquent.

### Utiliser la façade DB

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class UserSeeder extends Seeder
{
    public function run(): void
    {
        DB::table('users')->insert([
            [
                'name' => 'Taro Yamada',
                'email' => 'taro@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Hanako Suzuki',
                'email' => 'hanako@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }
}
```

### Utiliser les modèles Eloquent

```php theme={null}
use App\Models\User;
use Illuminate\Support\Facades\Hash;

public function run(): void
{
    User::create([
        'name' => 'Administrateur',
        'email' => 'admin@example.com',
        'password' => Hash::make('password'),
    ]);
}
```

<Info>
  Pendant l'exécution des seeders, la protection contre l'assignation en masse est automatiquement désactivée. Vous pouvez insérer des données sans vous soucier des réglages `$fillable` ou `$guarded`.
</Info>

## Combinaison avec les factories

Pour de grandes quantités de données de test, la combinaison avec les [factories de modèles](/fr/eloquent) est pratique. Elles génèrent des données aléatoires en masse.

```php theme={null}
use App\Models\User;
use App\Models\Post;

public function run(): void
{
    // Crée 10 utilisateurs
    User::factory(10)->create();

    // Crée 3 publications pour chaque utilisateur
    User::factory(5)
        ->hasPosts(3)
        ->create();
}
```

<Tip>
  Pour l'usage détaillé des factories, consultez la documentation des factories Eloquent.
</Tip>

## Utilisation de DatabaseSeeder

`DatabaseSeeder` est le point d'entrée qui orchestre plusieurs seeders. Utilisez `call()` pour spécifier ceux à exécuter.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            UserSeeder::class,
            PostSeeder::class,
            CommentSeeder::class,
        ]);
    }
}
```

Les seeders sont exécutés dans l'ordre passé à `call()`. En présence de contraintes de clé étrangère, seedez d'abord les tables référencées (par exemple, `users` → `posts`).

## Exécuter les seeders

### Exécuter tous les seeders

```shell theme={null}
php artisan db:seed
```

`DatabaseSeeder` est invoqué et exécute ensuite dans l'ordre les seeders passés à `call()`.

### Exécuter un seeder spécifique

L'option `--class` permet de spécifier la classe à exécuter.

```shell theme={null}
php artisan db:seed --class=UserSeeder
```

## Exécuter en même temps que les migrations

L'option `--seed` de `migrate:fresh` recrée toutes les tables puis exécute les seeders en une seule commande.

```shell theme={null}
php artisan migrate:fresh --seed
```

Pour n'exécuter qu'un seeder particulier, utilisez `--seeder`.

```shell theme={null}
php artisan migrate:fresh --seed --seeder=UserSeeder
```

<Warning>
  `migrate:fresh` supprime et recrée toutes les tables. Toutes les données existantes seront perdues ; ne l'utilisez donc pas en production.
</Warning>

## Exécution en production

Lancer un seeding en production affiche une invite de confirmation. Pour l'exécuter sans confirmation, utilisez `--force`.

```shell theme={null}
php artisan db:seed --force
```

<Warning>
  Un seeding en production peut écraser ou perdre des données. Faites toujours une sauvegarde avant d'exécuter.
</Warning>

## Suppression des événements de modèle

Pour empêcher le déclenchement des événements de modèle (`creating`, `created`, etc.) pendant le seeding, utilisez le trait `WithoutModelEvents`.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Database\Console\Seeds\WithoutModelEvents;

class DatabaseSeeder extends Seeder
{
    use WithoutModelEvents;

    public function run(): void
    {
        $this->call([
            UserSeeder::class,
        ]);
    }
}
```

Ce trait s'applique aussi aux seeders enfants appelés via `call()`.

## Exemple pratique : seeder d'une application de blog

Voici un exemple de mise en place de données initiales pour une application de blog avec utilisateurs et publications.

```php theme={null}
// database/seeders/UserSeeder.php
class UserSeeder extends Seeder
{
    public function run(): void
    {
        User::factory(10)->create();
    }
}

// database/seeders/PostSeeder.php
class PostSeeder extends Seeder
{
    public function run(): void
    {
        // Crée 2 à 5 publications pour chaque utilisateur
        User::all()->each(function ($user) {
            Post::factory(rand(2, 5))->create([
                'user_id' => $user->id,
            ]);
        });
    }
}

// database/seeders/DatabaseSeeder.php
class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            UserSeeder::class,
            PostSeeder::class, // Exécuté après users
        ]);
    }
}
```

Commande d'exécution :

```shell theme={null}
php artisan migrate:fresh --seed
```

## Prochaines étapes

<Card title="Introduction à Eloquent" icon="database" href="/fr/eloquent">
  Apprenez à récupérer et manipuler les données insérées via l'ORM Eloquent.
</Card>


## Related topics

- [Migrations de base de données](/fr/migrations.md)
- [Configuration de la base de données](/fr/database.md)
- [Tests de base de données](/fr/database-testing.md)
- [Core — opérations AT Protocol de base](/fr/packages/laravel-bluesky/core.md)
- [Mise à niveau de Laravel 9 vers 10](/fr/blog/upgrade-9-to-10.md)