# Migrações e Seeders

%[https://www.youtube.com/watch?v=CUeo492WY4Y&t=293s] 

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768487067112/b2f182bc-f34f-4f44-b8ee-99be4c470cd7.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

#### Introdução

Gerenciar o esquema do banco de dados de maneira controlada e repetível é uma necessidade crucial em qualquer aplicação. No Laravel, isso é facilitado por migrações e seeders.

As migrações permitem criar e modificar tabelas no banco de dados, enquanto os seeders são usados para popular tabelas com dados iniciais ou de teste.

### Migrações

##### O Que São Migrações?

Migrações são como controle de versão para o banco de dados. Elas permitem que você modifique a estrutura do banco de dados de maneira incremental e segura.

##### Criando uma Migração

Você pode criar uma migração usando o Artisan CLI:

```bash
php artisan make:migration create_fruits_table
```

Isso criará um arquivo de migração em `database/migrations`. Um arquivo de migração típico tem dois métodos: `up` e `down`. O método `up` é usado para aplicar as alterações no banco de dados, enquanto o método `down` desfaz essas alterações.

```php-template
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateFruitsTable extends Migration
{
    public function up()
    {
        Schema::create('fruits', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('color');    
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('fruits');
    }
}
```

##### Executando Migrações

Para executar todas as migrações pendentes, use o comando:

```bash
sail artisan migrate
```

Para reverter a última migração, use:

```bash
sail artisan migrate:rollback
```

##### Modificando Tabelas Existentes

Você pode criar uma migração para modificar uma tabela existente:

```bash
sail artisan make:migration add_price_to_fruits_table --table=fruits
```

No método `up`, você define as alterações:

```php-template
<?php
    public function up()
    {
        Schema::table('fruits', function (Blueprint $table) {
            $table->integer('price')->nullable();
        });
    }
    
    public function down()
    {
        Schema::table('fruits', function (Blueprint $table) {
            $table->dropColumn('price');
        });
    }
```

### Seeders

##### O Que São Seeders?

Seeders são classes usadas para popular o banco de dados com dados iniciais ou de teste. Eles são úteis para preencher tabelas com dados que você pode usar durante o desenvolvimento ou para testar sua aplicação.

##### Criando um Seeder

Você pode criar um seeder usando o Artisan CLI:

```bash
sail artisan make:seeder FruitsTableSeeder
```

Isso criará um arquivo de seeder em `database/seeders`. Você pode definir os dados a serem inseridos no método `run`:

```php-template
<?php
use Illuminate\Database\Seeder;
use App\Models\Fruit;

class FruitsTableSeeder extends Seeder
{
    public function run()
    {
        Fruit::create([
            'name' => 'Abacaxi',
            'color' => 'Amarelo',
        ]);

        Fruit::create([
            'name' => 'Banana',
            'color' => 'Amarela',
        ]);
    }
}
```

##### Executando Seeders

Para executar todos os seeders, use o comando:

```bash
sail artisan db:seed
```

Lembre-se de adicionar o seeder criado dentro do DatabaseSeeder.php

```php-template
$this->call(FruitsTableSeeder::class);
```

Para executar um seeder específico, use:

```bash
sail artisan db:seed --class=FruitsTableSeeder
```

### Models

Uma **model** no Laravel (e em muitos outros frameworks MVC - Model-View-Controller) é uma classe que representa uma entidade da aplicação, geralmente ligada a uma tabela específica no banco de dados. A model serve como a camada intermediária entre a aplicação e o banco de dados, facilitando o gerenciamento de dados.

```php-template
sail artisan make:model Fruit
```

```php-template
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Fruit extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'color',
        'price',
    ];
}
```

### Factories e Seeders

Factories são frequentemente usadas em conjunto com seeders para gerar dados de teste realistas. Primeiro, você cria uma factory:

```bash
sail artisan make:factory FruitFactory --model=Fruit
```

No arquivo da factory, você define como os dados fictícios devem ser gerados:

```php-template
<?php

namespace Database\Factories;

use App\Models\Fruit;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class FruitFactory extends Factory
{
    protected $model = Fruit::class;

    public function definition()
    {
        return [
            'name' => $this->faker->word,
            'color' => $this->faker->safeColorName,
            'price' => $this->faker->randomFloat(2, 1000, 5000),
        ];
    }
}
```

No seeder, você pode usar a factory para criar múltiplos registros:

```php-template
<?php
use Illuminate\Database\Seeder;
use App\Models\Fruit;

class FruitsTableSeeder extends Seeder
{
    public function run()
    {
        Fruit::factory()->count(10)->create();
    }
}
```

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768487082750/061b24fe-310e-4615-af50-7e62e1195425.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

### Conclusão

Migrações e seeders são ferramentas poderosas no Laravel para gerenciar o esquema do banco de dados e popular tabelas de forma controlada e repetível. Elas permitem que você mantenha o banco de dados sincronizado e cheio de dados úteis durante o desenvolvimento e testes. Nos próximos tópicos, exploraremos outras funcionalidades avançadas do Laravel para continuar aprimorando suas habilidades no desenvolvimento de aplicações robustas e eficientes.