Laravel
Seed av databaser

Kör en Seeder

Du kan lägga till din nya Seeder i klassen DatabaseSeeder.

    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        $this->call(UserTableSeeder::class);
    }

Använd kommandot Artisan för att köra en databas seeder

php artisan db:seed

Detta kör klassen DatabaseSeeder. Du kan också välja att använda alternativet --class= att manuellt ange vilken seeder som ska köras.

* Observera, du kan behöva köra kompositdumpautoload om din Seeder-klass inte kan hittas. Detta händer vanligtvis om du manuellt skapar en seeder-klass istället för att använda hantverkskommandot.

Skapa ett frö

Databasfrön lagras i katalogen / databas / frön. Du kan skapa ett frö med ett hantverkskommando.

php artisan make:seed UserTableSeeder

Alternativt kan du skapa en ny klass som utvidgar Illuminate\Database\Seeder . Klassen måste ha en offentlig funktion som heter run() .

Infoga data med en Seeder

Du kan referera till modeller i en seeder.

use DB;
use App\Models\User;

class UserTableSeeder extends Illuminate\Database\Seeder{

    public function run(){
        # Remove all existing entrie
        DB::table('users')->delete() ;
        User::create([
            'name' => 'Admin',
            'email' => '[email protected]',
            'password' => Hash::make('password')
        ]);

    }
}

Infoga data med en modellfabrik

Du kanske vill använda modellfabriker i dina frön. Detta skapar 3 nya användare.

use App\Models\User;

class UserTableSeeder extends Illuminate\Database\Seeder{

    public function run(){
        factory(User::class)->times(3)->create();    
    }
}

Du kanske också vill definiera specifika fält på sådd som t.ex. ett lösenord. Detta skapar 3 användare med samma lösenord.

factory(User::class)->times(3)->create(['password' => '123456']);    

Sådd med MySQL Dump

Följ tidigare exempel på att skapa ett frö. I det här exemplet används en MySQL Dump för att sätta en tabell i projektdatabasen. Tabellen måste skapas före sådd.

<?php

use Illuminate\Database\Seeder;

class UserTableSeeder extends Seeder
{

    /**
     * Run the database seeds.
     *
     * @return void
     */
     public function run()
     {
         $sql = file_get_contents(database_path() . '/seeds/users.sql');
    
         DB::statement($sql);
      }
}

Vår $ sql kommer att vara innehållet i våra användare.sql dumpning. Dumpningen bör ha ett INSERT INTO-uttalande. Det är upp till dig där du lagrar dina dumpar. I exemplet ovan lagras det i projektkatalogen \database\seeds . Använda laravels hjälpfunktion database_path() och lägg till katalogen och filnamnet på dumpningen.

INSERT INTO `users` (`id`, `name`, `email`, `password`, `remember_token`, `created_at`, `updated_at`) VALUES
(1, 'Jane', '[email protected]', 'superSecret', NULL, '2016-07-21 00:00:00', '2016-07-21 00:00:00'),
(2, 'John', '[email protected]', 'sup3rS3cr3t', NULL, '2016-07-21 00:00:00', '2016-07-21 00:00:00');

DB::statement($sql) kommer att köra bilagorna när Seeder har körts. Som i tidigare exempel kan du placera UserTableSeeder i klassen DatabaseSeeder från laravel:

<?php

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        $this->call(UserTableSeeder::class);
    }
}

och kör från CLI i projektkatalog php artisan db:seed . Eller så kan du köra Seeder för en enda klass med php artisan db:seed --class=UsersTableSeeder

Använda faker And ModelFactories för att generera frön

1) GRUNDLÄGGANDE ENKEL VÄG

Databasdrivna applikationer behöver ofta förförd inlägg i systemet för test- och demoändamål.

För att skapa sådana data, skapar du först seeder-klassen

ProductTableSeeder

use Faker\Factory as Faker;
use App\Product;

class ProductTableSeeder extends DatabaseSeeder {

public function run()
{
    $faker = $this->getFaker();

    for ($i = 0; $i < 10; $i++)
    {
        $name =         $faker->word;
        $image =        $faker->imageUrl;
       
        Modelname::create([
            'name' => $name,
            'image' => $image,
        ]);
      }
    }
 }

För att ringa en för att kunna utföra en seeder-klass måste du ringa den från klassen DatabaseSeeder, helt enkelt genom att lämna namnet på den seeder du vill köra:

använd Illuminate \ Database \ Seeder;

class DatabaseSeeder extends Seeder {

    protected $faker;

    public function getFaker() {
        if (empty($this->faker)) {
            $faker = Faker\Factory::create();
            $faker->addProvider(new Faker\Provider\Base($faker));
            $faker->addProvider(new Faker\Provider\Lorem($faker));
        }
        return $this->faker = $faker;
    }
    public function run() {
        $this->call(ProductTableSeeder::class);
    }
}

Glöm inte att köra $ composer dump-autoload efter att du har skapat Seederen, eftersom de inte automatiskt laddas in av kompositören (såvida du inte skapade seeder av hantverkare kommando $ php artisan make:seeder Name )

Nu är du redo att frö genom att köra detta hantverkskommando php artisan db:seed

2) ANVÄNDNING av modellfabriker

Först och främst definierar du en standarduppsättning attribut för varje modell i App/database/factories/ModelFactory.php

Ta en användarmodell som ett exempel, så ser en ModelFactory ut

$factory->define(App\User::class, function (Faker\Generator $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->email,
        'password' => bcrypt(str_random(10)),
        'remember_token' => str_random(10),
    ];
});

Skapa nu en tabell seeder php artisan make:seeder UsersTableSeeder

Och lägg till detta

public function run()
{
    factory(App\User::class, 100)->create()
}

lägg sedan till detta i DatabaseSeeder

public function run()
{
    $this->call(UsersTableSeeder::class);
}

Detta kommer att sätta bordet med 100 poster.