> ## 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

> Come inserire nel database dati di esempio per lo sviluppo e per i test usando la funzione di seeding di Laravel.

## Cos'è il seeding

Il seeding è il meccanismo per inserire nel database dati di esempio o dati iniziali.

Nella configurazione di ambienti di sviluppo e nei test automatici serve avere dati già presenti. Poiché inserire manualmente i dati ogni volta è oneroso, si raccolgono in seeder eseguibili ripetutamente.

Le classi seeder si trovano nella directory `database/seeders`. Di default è già presente la classe `DatabaseSeeder`.

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

## Creazione di un seeder

Genera una nuova classe seeder con il comando Artisan `make:seeder`.

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

Il file generato viene collocato in `database/seeders/UserSeeder.php`.

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

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder
{
    /**
     * Esegue il seeder
     */
    public function run(): void
    {
        // Qui scrivi la logica di inserimento dei dati
    }
}
```

## Implementazione del seeder

Scrivi la logica di inserimento dei dati all'interno del metodo `run()`. Puoi usare la facade DB oppure i modelli Eloquent.

### Usando la facade 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' => 'Mario Rossi',
                'email' => 'mario@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Giulia Bianchi',
                'email' => 'giulia@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }
}
```

### Usando i modelli Eloquent

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

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

<Info>
  Durante l'esecuzione del seeding la protezione da mass assignment viene disabilitata automaticamente. Puoi inserire dati senza preoccuparti delle impostazioni di `$fillable` o `$guarded`.
</Info>

## Combinazione con le model factory

Quando servono grandi quantità di dati di test, è utile combinare i seeder con le [model factory](/it/eloquent). Con le factory puoi generare in blocco dati fittizi casuali.

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

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

    // Crea 3 post per ciascun utente
    User::factory(5)
        ->hasPosts(3)
        ->create();
}
```

<Tip>
  Per i dettagli sull'uso delle factory consulta la documentazione delle factory Eloquent.
</Tip>

## Come usare DatabaseSeeder

`DatabaseSeeder` è il punto di ingresso per gestire in modo unificato più seeder. Con il metodo `call()` specifichi quali seeder eseguire.

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

I seeder vengono eseguiti nell'ordine passato a `call()`. In presenza di vincoli di chiave esterna, ordina in modo da seedare prima le tabelle referenziate (ad esempio `users` → `posts`).

## Esecuzione dei seeder

### Eseguire tutti i seeder

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

Viene invocato `DatabaseSeeder` e, da lì, vengono eseguiti in ordine i seeder specificati con `call()`.

### Eseguire solo un seeder specifico

Con l'opzione `--class` puoi specificare la classe seeder da eseguire.

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

## Esecuzione insieme alle migration

Aggiungendo l'opzione `--seed` al comando `migrate:fresh`, puoi ricreare tutte le tabelle e poi eseguire in blocco il seeding.

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

Se vuoi eseguire solo un seeder specifico usa l'opzione `--seeder`.

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

<Warning>
  `migrate:fresh` elimina e ricrea tutte le tabelle. Tutti i dati esistenti andranno persi, quindi non usarlo in produzione.
</Warning>

## Esecuzione in produzione

Se provi a eseguire il seeding in produzione viene mostrato un prompt di conferma. Per eseguirlo senza conferma usa il flag `--force`.

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

<Warning>
  Il seeding in produzione può causare sovrascritture o perdite di dati. Esegui sempre un backup prima di procedere.
</Warning>

## Soppressione degli eventi del modello

Se vuoi impedire che durante il seeding vengano emessi eventi del modello (`creating`, `created`, ecc.), usa il 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,
        ]);
    }
}
```

Si applica anche ai seeder figli eseguiti tramite `call()`.

## Esempio pratico: seeder per un'app blog

Esempio di configurazione dei dati iniziali per un'applicazione blog con utenti e post.

```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
    {
        // Crea da 2 a 5 post per ciascun utente
        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, // eseguito dopo users
        ]);
    }
}
```

Passi di esecuzione:

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

## Prossimi passi

<Card title="Introduzione a Eloquent" icon="database" href="/it/eloquent">
  Impara a recuperare e manipolare con Eloquent ORM i dati inseriti tramite i seeder.
</Card>


## Related topics

- [Migration del database](/it/migrations.md)
- [Eloquent Factory](/it/eloquent-factories.md)
- [Configurazione del database](/it/database.md)
- [Test del database](/it/database-testing.md)
- [Test avanzati con Pest](/it/advanced/testing-pest.md)