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

# Datenbank-Seeding

> Erfahren Sie, wie Sie mit Laravels Seeding-Funktion Beispiel- und Testdaten in die Datenbank einspielen.

## Was ist Seeding

Seeding ist ein Mechanismus, um Beispiel- oder Ausgangsdaten in Ihre Datenbank zu schreiben.

Beim Einrichten der Entwicklungsumgebung oder bei automatisierten Tests benötigen Sie oft eine Datenbank in einem vordefinierten Zustand. Statt jedes Mal manuell zu befüllen, bündeln Sie das Vorgehen in Seeder-Klassen.

Seeder liegen unter `database/seeders`. Standardmäßig existiert die Klasse `DatabaseSeeder`.

```mermaid theme={null}
flowchart TD
    A["php artisan db:seed"] --> B["DatabaseSeeder::run()"]
    B --> C["UserSeeder::run()"]
    B --> D["PostSeeder::run()"]
    C --> E["Daten in Tabelle users einfügen"]
    D --> F["Daten in Tabelle posts einfügen"]
```

## Seeder erzeugen

Neue Seeder erzeugen Sie mit `make:seeder`.

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

Ergebnis: `database/seeders/UserSeeder.php`.

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

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder
{
    /**
     * Seeder ausführen
     */
    public function run(): void
    {
        // Datenlogik hier
    }
}
```

## Seeder implementieren

Die Logik zur Datenerzeugung schreiben Sie in `run()`. Sie können sowohl die `DB`-Facade als auch Eloquent verwenden.

### Mit der DB-Facade

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

### Mit Eloquent

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

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

<Info>
  Während des Seedings ist der Mass-Assignment-Schutz automatisch deaktiviert. `$fillable` und `$guarded` müssen Sie nicht beachten.
</Info>

## Kombination mit Model Factories

Für viele Testdaten sind [Model Factories](/de/eloquent) ideal. Sie erzeugen zufällige Dummy-Daten in Massen.

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

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

    // Für jeden Benutzer 3 Beiträge
    User::factory(5)
        ->hasPosts(3)
        ->create();
}
```

<Tip>
  Details zu Factories finden Sie in der Dokumentation zu Eloquent-Factories.
</Tip>

## Der DatabaseSeeder

`DatabaseSeeder` ist der Einstiegspunkt, um mehrere Seeder zu koordinieren. Mit `call()` bestimmen Sie, welche ausgeführt werden.

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

Die Reihenfolge entspricht der Übergabe. Wenn Fremdschlüssel im Spiel sind, seeden Sie referenzierte Tabellen zuerst (z. B. `users` → `posts`).

## Seeder ausführen

### Alle ausführen

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

Ruft `DatabaseSeeder` auf, der die in `call()` gelisteten Seeder abarbeitet.

### Nur einen bestimmten Seeder

Mit `--class`.

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

## Zusammen mit Migrationen

Mit `migrate:fresh --seed` legen Sie alle Tabellen neu an und seeden anschließend.

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

Auf einen bestimmten Seeder beschränken via `--seeder`.

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

<Warning>
  `migrate:fresh` löscht und erstellt alle Tabellen neu – bestehende Daten sind weg. Nicht in Produktion nutzen.
</Warning>

## Ausführung in Produktion

In Produktion erscheint eine Bestätigungsabfrage. Mit `--force` überspringen Sie sie.

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

<Warning>
  Seeding in Produktion kann bestehende Daten überschreiben. Legen Sie vorher immer ein Backup an.
</Warning>

## Modell-Events unterdrücken

Um zu verhindern, dass Modell-Events wie `creating`/`created` beim Seeding gefeuert werden, nutzen Sie den 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,
        ]);
    }
}
```

Der Trait wirkt auch auf die per `call()` aufgerufenen Sub-Seeder.

## Beispiel: Seeder einer Blog-Anwendung

Initialdaten für Nutzer und Beiträge:

```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
    {
        // Jeder Nutzer bekommt 2–5 Beiträge
        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, // nach users
        ]);
    }
}
```

Ausführen:

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

## Nächste Schritte

<Card title="Einstieg in Eloquent" icon="database" href="/de/eloquent">
  Nutzen Sie die geseedeten Daten in Ihren Eloquent-Abfragen.
</Card>


## Related topics

- [Datenbank-Migrationen](/de/migrations.md)
- [Eloquent-Factories](/de/eloquent-factories.md)
- [Datenbankkonfiguration](/de/database.md)
- [Datenbanktests](/de/database-testing.md)
- [Suche](/de/search.md)