Laravel
Siembra de base de datos

Corriendo una sembradora

Puede agregar su nueva Sembradora a la clase DatabaseSeeder.

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

Para ejecutar una sembradora de bases de datos, use el comando Artisan

php artisan db:seed

Esto ejecutará la clase DatabaseSeeder. También puede elegir usar la opción --class= para especificar manualmente qué sembradora ejecutar.

* Tenga en cuenta que es posible que tenga que ejecutar el dumpautoload del compositor si no se puede encontrar su clase Seeder. Esto suele suceder si crea manualmente una clase sembradora en lugar de usar el comando artisan.

Creando una semilla

Las semillas de la base de datos se almacenan en el directorio / database / seeds. Puedes crear una semilla usando un comando Artesano.

php artisan make:seed UserTableSeeder

Alternativamente, puede crear una nueva clase que amplíe Illuminate\Database\Seeder . La clase debe una función pública llamada run() .

Insertando datos usando una sembradora

Puede hacer referencia a modelos en una sembradora.

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')
        ]);

    }
}

Insertando datos con un Model Factory

Es posible que desee utilizar Fábricas de modelos dentro de sus semillas. Esto creará 3 nuevos usuarios.

use App\Models\User;

class UserTableSeeder extends Illuminate\Database\Seeder{

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

También puede definir campos específicos en su siembra como una contraseña, por ejemplo. Esto creará 3 usuarios con la misma contraseña.

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

Siembra con MySQL Dump

Siga el ejemplo anterior de crear una semilla. Este ejemplo utiliza un volcado de MySQL para generar una tabla en la base de datos del proyecto. La tabla debe ser creada antes de la siembra.

<?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);
      }
}

Nuestro $ sql será el contenido de nuestro volcado users.sql. El volcado debe tener una instrucción INSERT INTO. Dependerá de usted dónde almacene sus vertederos. En el ejemplo anterior, se almacena en el directorio del proyecto \database\seeds . Utilizando la función helper de laravel database_path() y agregando el directorio y el nombre de archivo del volcado.

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) ejecutará las inserciones una vez que se ejecuta la Sembradora. Como en los ejemplos anteriores, puede colocar el UserTableSeeder en la clase DatabaseSeeder proporcionada por laravel:

<?php

use Illuminate\Database\Seeder;

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

y ejecute desde CLI en el directorio de proyectos php artisan db:seed . O puede ejecutar la Sembradora para una sola clase usando php artisan db:seed --class=UsersTableSeeder

Usando faker y ModelFactories para generar semillas

1) VÍA SIMPLE BÁSICA

Las aplicaciones basadas en bases de datos a menudo necesitan datos pre-sembrados en el sistema para fines de prueba y demostración.

Para hacer tales datos, primero cree la clase sembradora

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

Para llamar a una clase de ser capaz de ejecutar una sembradora, debe llamarla desde la clase DatabaseSeeder, simplemente al pasar el nombre de la sembradora que desea ejecutar:

utilizar 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);
    }
}

No se olvide de ejecutar $ composer dump-autoload después de crear la Sembradora, ya que el compositor no los carga automáticamente (a menos que haya creado la sembradora con el comando artesanal $ php artisan make:seeder Name )

Ahora está listo para sembrar ejecutando este comando php artisan db:seed

2) UTILIZANDO Fábricas de modelos

En primer lugar, debe definir un conjunto predeterminado de atributos para cada modelo en App/database/factories/ModelFactory.php

Tomando como ejemplo un modelo de usuario, este es el aspecto de ModelFactory

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

Ahora php artisan make:seeder UsersTableSeeder una tabla sembradora php artisan make:seeder UsersTableSeeder

Y agrega esto

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

A continuación, agregue esto al DatabaseSeeder

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

Esto sembrará la tabla con 100 registros.