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

# Database seeding

> Uitleg over hoe je met de seeding-functionaliteit van Laravel voorbeelddata voor ontwikkeling en tests in de database laadt.

## Wat is seeding

Seeding is het mechanisme waarmee je voorbeeld- of initiële data in de database laadt.

Bij het opzetten van een ontwikkelomgeving of in geautomatiseerde tests heb je een database nodig die al data bevat. Elke keer handmatig data invoeren is omslachtig, dus bundel je dit met seeders in een vorm die herhaaldelijk uitvoerbaar is.

Seederklassen staan in de map `database/seeders`. Standaard is er een klasse `DatabaseSeeder` aanwezig.

```mermaid theme={null}
flowchart TD
    A["php artisan db:seed"] --> B["DatabaseSeeder::run()"]
    B --> C["UserSeeder::run()"]
    B --> D["PostSeeder::run()"]
    C --> E["Data invoegen in de users-tabel"]
    D --> F["Data invoegen in de posts-tabel"]
```

## Een seeder maken

Met het Artisan-commando `make:seeder` genereer je een nieuwe seederklasse.

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

Het gegenereerde bestand wordt geplaatst in `database/seeders/UserSeeder.php`.

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

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder
{
    /**
     * Voer de seeder uit
     */
    public function run(): void
    {
        // Schrijf hier de logica om data in te voegen
    }
}
```

## Een seeder implementeren

In de methode `run()` schrijf je de logica om data in te voegen. Je kunt invoegen via de DB-facade of via Eloquent-modellen.

### De DB-facade gebruiken

```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' => 'Yamada Taro',
                'email' => 'taro@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Suzuki Hanako',
                'email' => 'hanako@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }
}
```

### Eloquent-modellen gebruiken

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

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

<Info>
  Tijdens het seeden is de mass-assignmentbescherming automatisch uitgeschakeld. Je kunt data invoegen zonder je zorgen te maken over de instellingen van `$fillable` of `$guarded`.
</Info>

## Combineren met model factories

Heb je grote hoeveelheden testdata nodig, dan is de combinatie met [model factories](/nl/eloquent) handig. Met factories genereer je in één keer willekeurige dummy-data.

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

public function run(): void
{
    // 10 gebruikers aanmaken
    User::factory(10)->create();

    // Voor elke gebruiker 3 posts aanmaken
    User::factory(5)
        ->hasPosts(3)
        ->create();
}
```

<Tip>
  Zie de documentatie over Eloquent-factories voor gedetailleerd gebruik van factories.
</Tip>

## DatabaseSeeder gebruiken

De `DatabaseSeeder` is het startpunt waarmee je meerdere seeders centraal beheert. Met de methode `call()` geef je op welke seeders worden uitgevoerd.

```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,
        ]);
    }
}
```

De seeders worden uitgevoerd in de volgorde waarin je ze aan `call()` doorgeeft. Zijn er foreign key-constraints, kies dan een volgorde waarin de tabellen waarnaar wordt verwezen eerst worden geseed (bijvoorbeeld `users` → `posts`).

## Seeders uitvoeren

### Alle seeders uitvoeren

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

De `DatabaseSeeder` wordt aangeroepen en vervolgens worden de via `call()` opgegeven seeders op volgorde uitgevoerd.

### Alleen een specifieke seeder uitvoeren

Met de optie `--class` geef je de uit te voeren seederklasse op.

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

## Tegelijk met migraties uitvoeren

Voeg de optie `--seed` toe aan het commando `migrate:fresh` om alle tabellen opnieuw aan te maken en daarna in één keer te seeden.

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

Wil je alleen een specifieke seeder uitvoeren, gebruik dan de optie `--seeder`.

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

<Warning>
  `migrate:fresh` verwijdert alle tabellen en maakt ze opnieuw aan. Alle bestaande data gaat verloren; gebruik dit dus niet in productie.
</Warning>

## Uitvoeren in productie

Probeer je te seeden in een productieomgeving, dan verschijnt er een bevestigingsprompt. Om zonder bevestiging uit te voeren gebruik je de vlag `--force`.

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

<Warning>
  Seeden in productie kan leiden tot het overschrijven of verliezen van data. Maak vóór het uitvoeren altijd een back-up.
</Warning>

## Modelevents onderdrukken

Wil je voorkomen dat tijdens het seeden modelevents (`creating`, `created` enz.) worden afgevuurd, gebruik dan de 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,
        ]);
    }
}
```

Dit geldt ook voor kindseeders die via `call()` worden uitgevoerd.

## Praktijkvoorbeeld: seeders voor een blogapp

Een voorbeeld waarin de initiële data voor een blogapp met gebruikers en posts wordt opgezet.

```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
    {
        // Voor elke gebruiker 2 tot 5 posts aanmaken
        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, // Na users uitvoeren
        ]);
    }
}
```

Uitvoering:

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

## Volgende stap

<Card title="Introductie Eloquent" icon="database" href="/nl/eloquent">
  Leer hoe je de met seeders geladen data ophaalt en bewerkt met het Eloquent ORM.
</Card>


## Related topics

- [Databaseconfiguratie](/nl/database.md)
- [Eloquent-factories](/nl/eloquent-factories.md)
- [Databasemigraties](/nl/migrations.md)
- [Databasetests](/nl/database-testing.md)
- [Geavanceerd testen met Pest](/nl/advanced/testing-pest.md)