Ricerca…
Esecuzione di una seminatrice
Puoi aggiungere la tua nuova seminatrice alla classe DatabaseSeeder.
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$this->call(UserTableSeeder::class);
}
Per eseguire una seminatrice di database, utilizzare il comando Artisan
php artisan db:seed
Questo eseguirà la classe DatabaseSeeder. Puoi anche scegliere di usare l'opzione --class= per specificare manualmente quale seminatrice eseguire.
* Nota, potrebbe essere necessario eseguire dumpautoload di composer se non è possibile trovare la classe Seeder. Ciò accade in genere se si crea manualmente una classe seminatrice invece di utilizzare il comando artisan.
Creare un seme
I semi del database sono memorizzati nella directory / database / semi. Puoi creare un seme usando un comando Artisan.
php artisan make:seed UserTableSeeder
In alternativa puoi creare una nuova classe che estende Illuminate\Database\Seeder . La classe deve avere una funzione pubblica chiamata run() .
Inserimento di dati utilizzando una seminatrice
Puoi fare riferimento a modelli in una seminatrice.
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')
]);
}
}
Inserimento di dati con una fabbrica modello
Potresti usare le Fabbriche di modelli nei tuoi semi. Questo creerà 3 nuovi utenti.
use App\Models\User;
class UserTableSeeder extends Illuminate\Database\Seeder{
public function run(){
factory(User::class)->times(3)->create();
}
}
Ad esempio, potresti anche voler definire campi specifici sul tuo seeding come una password. Questo creerà 3 utenti con la stessa password.
factory(User::class)->times(3)->create(['password' => '123456']);
Semina con MySQL Dump
Segui l'esempio precedente di creazione di un seme. In questo esempio viene utilizzato un dump MySQL per eseguire il seeding di una tabella nel database del progetto. La tabella deve essere creata prima della semina.
<?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);
}
}
Il nostro $ sql sarà il contenuto del nostro dump di users.sql. Il dump dovrebbe avere un'istruzione INSERT INTO. Spetterà a te dove conservi le discariche. Nell'esempio precedente, è memorizzato nella directory di progetto \database\seeds . Utilizzando la funzione helper di database_path() di laravel, database_path() e aggiungendo la directory e il nome del file del dump.
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) eseguirà gli inserti una volta eseguita la Seeder. Come negli esempi precedenti, puoi inserire UserTableSeeder nella classe DatabaseSeeder fornita da laravel:
<?php
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$this->call(UserTableSeeder::class);
}
}
ed eseguire dalla CLI nella directory di progetto php artisan db:seed . Oppure puoi eseguire la Seminatrice per una singola classe usando php artisan db:seed --class=UsersTableSeeder
Usare faker e ModelFactories per generare semi
1) MODO SEMPLICE DI BASE
Le applicazioni basate su database spesso richiedono dati pre-seminati nel sistema per scopi di test e dimostrativi.
Per rendere tali dati, prima creare la classe seminatrice
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,
]);
}
}
}
Per chiamare un essere in grado di eseguire una classe di seminatrice, è necessario chiamarlo dalla classe DatabaseSeeder, semplicemente passando il nome della seminatrice che si desidera eseguire:
usa 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);
}
}
Non dimenticare di eseguire $ composer dump-autoload dopo aver creato la Seeder, dal momento che non vengono automaticamente caricati automaticamente dal compositore (a meno che tu non abbia creato la seminatrice tramite il comando artisan $ php artisan make:seeder Name )
Ora sei pronto per seminare eseguendo questo comando php artisan db:seed
2) UTILIZZO DELLE FABBRICHE DEL MODELLO
Prima di tutto devi definire un set predefinito di attributi per ciascun modello in App/database/factories/ModelFactory.php
Assunzione di un modello Utente come esempio, Ecco come appare 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),
];
});
Ora crea una seminatrice da tavolo php artisan make:seeder UsersTableSeeder
E aggiungi questo
public function run()
{
factory(App\User::class, 100)->create()
}
quindi aggiungere questo al DatabaseSeeder
public function run()
{
$this->call(UsersTableSeeder::class);
}
Questo semina la tabella con 100 record.
